%%% -*-BibTeX-*-
%%% ====================================================================
%%%  BibTeX-file{
%%%     author          = "Nelson H. F. Beebe",
%%%     version         = "1.235",
%%%     date            = "05 March 2025",
%%%     time            = "07:42:47 MST",
%%%     filename        = "java2010.bib",
%%%     address         = "University of Utah
%%%                        Department of Mathematics, 110 LCB
%%%                        155 S 1400 E RM 233
%%%                        Salt Lake City, UT 84112-0090
%%%                        USA",
%%%     telephone       = "+1 801 581 5254",
%%%     URL             = "https://www.math.utah.edu/~beebe",
%%%     checksum        = "18322 39955 200616 2009218",
%%%     email           = "beebe at math.utah.edu, beebe at acm.org,
%%%                        beebe at computer.org (Internet)",
%%%     codetable       = "ISO/ASCII",
%%%     keywords        = "bibliography; BibTeX; HotJava; HotJava;
%%%                        HotJavaBean; HTML; Java; Java3D; JavaBean;
%%%                        JavaChip; JavaCUP; JavaDev; JavaDump;
%%%                        JavaEngine; JavaLanche; JavaLex; JavaMan;
%%%                        JavaManagement; JavaOne; JavaOS; JavaPVM;
%%%                        JavaQ; JavaScript; JavaSoft; JavaSpace;
%%%                        JavaStation; JavaStations; JavaStudio;
%%%                        JavaTalk; JBuilder; JChat; JClass; Jcon;
%%%                        JDKs; JetAssist; JetForm; JFactory; JLex;
%%%                        JPython; JRes; JSafe; JScape; JScript;
%%%                        JScriptTest; JSpace; JTable; JTAPI; KJPrice;
%%%                        MacJava; MetaJava; NexusJava; PersonalJava;
%%%                        picoJava; PJAmi; PowerJ; Scala; SpecJava;
%%%                        TclJava; TowerJ; World Wide Web; WWW",
%%%     license         = "public domain",
%%%     supported       = "yes",
%%%     docstring       = "This bibliography records books and other
%%%                        publications about the Java programming
%%%                        language, and related software, for the years
%%%                        2010--2019.  The companion bibliography,
%%%                        java.bib, covers the years 1995--1999, and
%%%                        java2000.bib covers 2000--2009.
%%%
%%%                        At version 1.235, year coverage looked
%%%                        like this:
%%%
%%%                             2001 (   1)    2008 (   0)    2015 (  88)
%%%                             2002 (   0)    2009 (   0)    2016 (  78)
%%%                             2003 (   0)    2010 ( 107)    2017 ( 106)
%%%                             2004 (   0)    2011 (  79)    2018 (  81)
%%%                             2005 (   0)    2012 ( 157)    2019 (  62)
%%%                             2006 (   0)    2013 ( 108)
%%%                             2007 (   0)    2014 ( 120)
%%%
%%%                             Article:        923
%%%                             Book:            50
%%%                             InCollection:     1
%%%                             InProceedings:    7
%%%                             MastersThesis:    1
%%%                             Misc:             2
%%%                             Proceedings:      3
%%%
%%%                             Total entries:  987
%%%
%%%                        Further information on Java development and
%%%                        the HotJava WorldWideWeb browser can be
%%%                        found at the URL http://java.sun.com/.
%%%                        Netscape versions 2.03-beta or later
%%%                        support Java as well.
%%%
%%%                        A Java applet index and repository is
%%%                        available at http://www.gamelan.com/.
%%%
%%%                        Visix has extended their
%%%                        platform-independent window systems support
%%%                        to include Java; details are at
%%%                        http://www.visix.com/
%%%
%%%                        A tutorial on Java is available at
%%%                        http://java.sun.com/tutorial, a white paper
%%%                        on the Java language is at
%%%                        http://java.sun.com/1.0alpha3/doc/overview/
%%%                        java/index.html, and a white paper on the
%%%                        HotJava browser is at http://java.sun.com/
%%%                        1.0alpha3/doc/overview/hotjava/index.html.
%%%
%%%                        A status report on Java security problems
%%%                        is available at http://java.sun.com/sfaq;
%%%                        a good discussion of these issues can be
%%%                        found in the reference Hamilton:1996:JSN
%%%                        below.
%%%
%%%                        John December maintains a Java bibliography
%%%                        that includes press releases and online
%%%                        references at http://www.december.com/john//
%%%                        works/java/bib.html; a snapshot of that
%%%                        collection was incorporated in this
%%%                        bibliography on 17-Dec-1995.
%%%
%%%                        The Web site for Java World magazine is at
%%%                        http://www.javaworld.com/; many entries in
%%%                        this bibliography were found in resources
%%%                        there.
%%%
%%%                        An interesting press release detailing
%%%                        plans about Java-on-a-chip is available
%%%                        at http://www.sun.com:80/sparc/newsreleases/nr95-042.html.
%%%
%%%                        LINPACK benchmark results for Java on a
%%%                        number of different machines have recently
%%%                        been offered at
%%%                        http://www.netlib.org/benchmark/linpackjava/.
%%%                        If you use a Java-aware browser to visit
%%%                        that URL, you can run the benchmark on your
%%%                        own machine, and report the results back to
%%%                        the LINPACK developers.
%%%
%%%                        Other Java sites on the Internet include
%%%                        (see entry DeRoest:1996:PHP below):
%%%
%%%                        Java FAQS:
%%%                            http://www-net.com/java/faq
%%%                            http://lightyear.ncsa.uiuc.edu/~srp/java/javabooks.html
%%%                            http://www.digitalfocus.com/faq/
%%%                            http://www.afu.com/javafaq.html
%%%
%%%                        JavaScript handbook:
%%%                            http://home.netscape.com/eng/mozilla/2.0/handbook/javascript/index.html
%%%
%%%                        Java tutorials:
%%%                            http://www.neca.com/~vmis/java.html
%%%                            http://sunsite.unc.edu/javafaq/javafaq.html
%%%                            http://www.phrantic.com/scoop/onjava.html
%%%
%%%                        JavaScript tutorials:
%%%                            http://www.freqgrafx.com/411/tutorial.html
%%%                            http://ourworld.compuserve.com/homepages/voodoo/script.html
%%%
%%%                        Java and porting projects:
%%%                            http://www.javasoft.com/
%%%                            ftp://ftp4.netscape.com/pub/MacJava
%%%                            http://java.blackdown.org/java-linux.html
%%%                            http://www.osf.org/mall/web/javaport.htm
%%%                            http://www.lls.se/~matjo/PJAmi/PJAmi.html
%%%                            http://ncc.hursley.ibm.com/javainfo/ (IBM's
%%%                            official Java home page)
%%%                            http://www.hp.com/go/JAVA (Hewlett--Packard'
%%%                            official Java home page)
%%%
%%%                        Java books in languages other than English:
%%%                            http://lightyear.ncsa.uiuc.edu/~srp/java/japanese.html
%%%                            http://wwwiz.com/books/european.html
%%%
%%%                        Java books at Amazon bookstore (warning:
%%%                        also contains many entries for books about
%%%                        the island of Java in Indonesia):
%%%                            http://www.wholesaleproducts.com/computer-javascript.html
%%%                            http://www.wholesaleproducts.com/computer-java.html
%%%
%%%                        This bibliography was initially built from
%%%                        searches in the OCLC Content1st database.
%%%                        Additions were then made from all of the
%%%                        bibliographies in the TeX User Group
%%%                        collection, from bibliographies in the
%%%                        author's personal files, from the IEEE
%%%                        INSPEC CD-ROM database (1995--Sept 1996),
%%%                        from the Compendex database, from the
%%%                        UnCover database, and from the OCLC
%%%                        BooksInPrint database.
%%%
%%%                        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.
%%%
%%%                        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
%%%                        first by ascending year, and within each
%%%                        year, alphabetically by author or editor, and
%%%                        then, if necessary, by the 3-letter
%%%                        abbreviation at the end of the BibTeX
%%%                        citation tag, using the bibsort -byyear
%%%                        utility.  Year order has been chosen to make
%%%                        it easier to identify the most recent work.
%%%
%%%                        The checksum field above contains a CRC-16
%%%                        checksum as the first value, followed by the
%%%                        equivalent of the standard UNIX wc (word
%%%                        count) utility output of lines, words, and
%%%                        characters.  This is produced by Robert
%%%                        Solovay's checksum utility.",
%%%  }
%%% ====================================================================

@Preamble{"\input bibnames.sty " #
          "\input path.sty " #
          "\ifx \undefined \booktitle \def \booktitle #1{{{\em #1}}}    \fi" #
          "\ifx \undefined \circled   \def \circled   #1{(#1)}          \fi" #
          "\ifx \undefined \Dbar       \def \Dbar {\leavevmode\raise0.2ex\hbox{--}\kern-0.5emD} \fi" #
          "\ifx \undefined \k         \let \k = \c                      \fi" #
          "\ifx \undefined \pkg       \def \pkg       #1{{{\tt #1}}}    \fi" #
          "\ifx \undefined \reg       \def \reg         {\circled{R}}   \fi" #
          "\ifx \undefined \TM        \def \TM          {${}^{\sc TM}$} \fi" #
          "\hyphenation{
                        Aero-space
                        Gur-e-wich
                        Horst-mann
                        ROAST-ER
                        Rich-ard
                        Sep-tem-ber
                        data-bases
                        roast-er
          }"
}

%%% ====================================================================
%%% Acknowledgement abbreviations:

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

%%% ====================================================================
%%% Institution abbreviations:

@String{inst-CSC                = "Center for Scientific Computing, Department
                                  of Mathematics, University of Utah"}

@String{inst-CSC:adr            = "Salt Lake City, UT 84112, USA"}

%%% ====================================================================
%%% Journal abbreviations:

@String{j-ACM-COMM-COMP-ALGEBRA = "ACM Communications in Computer Algebra"}

@String{j-ADA-USER-J            = "Ada User Journal"}

@String{j-ADV-ENG-SOFTWARE      = "Advances in Engineering Software"}

@String{j-ADV-EXP-MED-BIO       = "Advances in experimental medicine and
                                  biology"}

@String{j-ADV-IMAGING           = "Advanced Imaging"}

@String{j-AMER-STAT             = "The American Statistician"}

@String{j-APL-QUOTE-QUAD        = "APL Quote Quad"}

@String{j-APPL-MATH-COMP        = "Applied Mathematics and Computation"}

@String{j-BIOINFORMATICS        = "Bioinformatics"}

@String{j-BUSINESS-WEEK         = "Business week"}

@String{j-CACM                  = "Communications of the ACM"}

@String{j-CCCUJ                 = "C/C++ Users Journal"}

@String{j-CCPE                  = "Concurrency and Computation: Prac\-tice and
                                  Experience"}

@String{j-CHEMO-INTELL-LAB      = "Chemometrics and Intelligent Laboratory
                                  Systems"}

@String{j-COMP-ARCH-NEWS        = "ACM SIGARCH Computer Architecture News"}

@String{j-COMP-CIVIL-ENG        = "Journal of Computing in Civil Engineering"}

@String{j-COMP-EDU-J            = "Computers in education journal"}

@String{j-COMP-GEOSCI           = "Computers and Geosciences"}

@String{j-COMP-J                = "The Computer Journal"}

@String{j-COMP-LANGS            = "Computer Languages"}

@String{j-COMP-LANGS-SYS-STRUCT = "Computer Languages, Systems and Structures"}

@String{j-COMP-MATH-APPL        = "Computers and Mathematics with
                                  Applications"}

@String{j-COMP-NET-AMSTERDAM    = "Computer Networks (Amsterdam, Netherlands:
                                  1999)"}

@String{j-COMP-PHYS-COMM        = "Computer Physics Communications"}

@String{j-COMP-STANDARDS-INTERFACES = "Computer Standards and Interfaces"}

@String{j-COMP-STAT             = "Computational Statistics"}

@String{j-COMP-STRUCTURES       = "Computers and Structures"}

@String{j-COMP-SURV             = "ACM Computing Surveys"}

@String{j-COMPUT-APPL-ENG-EDUC  = "Computer Applications in Engineering
                                  Education"}

@String{j-COMPUT-MATH-APPL      = "Computers and Mathematics with Applications"}

@String{j-COMPUT-BULL           = "The Computer Bulletin"}

@String{j-COMPUT-HUM-BEHAV      = "Computers in Human Behavior"}

@String{j-COMPUT-METH-PROG-BIOMED = "Computer Methods and Programs in
                                  Biomedicine"}

@String{j-COMPUT-SCI-ENG        = "Computing in Science and Engineering"}

@String{j-COMPUT-SECUR          = "Computers and Security"}

@String{j-COMPUTER              = "Computer"}

@String{j-COMPUTERS-AND-GRAPHICS = "Computers and Graphics"}

@String{j-COMPUTING             = "Computing"}

@String{j-CONTROL-ENG           = "Control Engineering"}

@String{j-CPE                   = "Concurrency: Prac\-tice and Experience"}

@String{j-DDJ                   = "Dr. Dobb's Journal of Software Tools"}

@String{j-EDN                   = "EDN"}

@String{j-ELECT-NOTES-THEOR-COMP-SCI = "Electronic Notes in Theoretical
                                  Computer Science"}

@String{j-ELECTRONIC-DESIGN     = "Electronic Design"}

@String{j-ELECTRONIC-ENG-TIMES  = "Electronic Engineering Times"}

@String{j-ELECTRONIC-LIBRARY    = "Electronic Library"}

@String{j-ELECTRONIK            = "Elektronik"}

@String{j-ELETTRONICA-OGGI      = "Elettronica Oggi"}

@String{j-EMBED-SYS-PROG        = "Embedded Systems Programming"}

@String{j-EMBEDDED-LINUX-J      = "Embedded Linux Journal"}

@String{j-EMPIR-SOFTWARE-ENG    = "Empirical Software Engineering"}

@String{j-FORM-METHODS-SYST-DES = "Formal Methods in System Design"}

@String{j-FORM-ASP-COMPUT       = "Formal Aspects of Computing"}

@String{j-FRONTIERS-EDU-CONF    = "Frontiers in Education Conference"}

@String{j-FUND-INFO             = "Fundamenta Informaticae"}

@String{j-FUT-GEN-COMP-SYS      = "Future Generation Computer Systems"}

@String{j-FUTURE-INTERNET       = "Future Internet"}

@String{j-HIGHER-ORDER-SYMB-COMPUT = "Higher-Order and Symbolic Computation"}

@String{j-IBM-JRD               = "IBM Journal of Research and Development"}

@String{j-IBM-SYS-J             = "IBM Systems Journal"}

@String{j-IEE-PROC-COMPUT-DIGIT-TECH = "IEE Proceedings. Computers and Digital
                                  Techniques"}

@String{j-IEEE-CGA              = "IEEE Computer Graphics and Applications"}

@String{j-IEEE-COMPUT-ARCHIT-LETT = "IEEE Computer Architecture Letters"}

@String{j-IEEE-CONCURR          = "IEEE Concurrency"}

@String{j-IEEE-DISTRIB-SYST-ONLINE = "IEEE Distributed Systems Online"}

@String{j-IEEE-MICRO            = "IEEE Micro"}

@String{j-IEEE-MULTIMEDIA       = "IEEE MultiMedia"}

@String{j-IEEE-SEC-PRIV         = "IEEE Security \& Privacy"}

@String{j-IEEE-SIGNAL-PROCESS-MAG = "IEEE signal processing magazine"}

@String{j-IEEE-SOFTWARE         = "IEEE Software"}

@String{j-IEEE-SPECTRUM         = "IEEE Spectrum"}

@String{j-IEEE-TRANS-BIG-DATA   = "IEEE Transactions on Big Data"}

@String{j-IEEE-TRANS-CONSUMER-ELECTRONICS = "IEEE Transactions on Consumer
                                  Electronics"}

@String{j-IEEE-TRANS-COMPUT     = "IEEE Transactions on Computers"}

@String{j-IEEE-TRANS-EDUC       = "IEEE transactions on education"}

@String{j-IEEE-TRANS-PAR-DIST-SYS = "IEEE Transactions on Parallel and
                                  Distributed Systems"}

@String{j-IEEE-TRANS-SOFTW-ENG  = "IEEE Transactions on Software Engineering"}

@String{j-IETE-TECH-REV         = "IETE Technical Review"}

@String{j-IJHPCA                = "The International Journal of High Performance
                                  Computing Applications"}

@String{j-INF-CONTROL           = "Information and Control"}

@String{j-INFO-PROC-LETT        = "Information Processing Letters"}

@String{j-INFO-RETRIEVAL-LIB-AUTO = "Information Retrieval and Library
                                  Automation"}

@String{j-INFO-SOFTWARE-TECH    = "Information and Software Technology"}

@String{j-INFORMATION-WEEK      = "Information Week"}

@String{j-INFOWORLD             = "InfoWorld"}

@String{j-INT-J-COMP-APPL       = "International Journal of Computer
                                  Applications"}

@String{j-INT-J-COMPUT-SYST-SCI-ENG = "International Journal of Computer Systems
                                  Science and Engineering"}

@String{j-INT-J-ENG-EDUC        = "International Journal of Engineering
                                  Education"}

@String{j-INT-J-INFO-SEC        = "International Journal of Information
                                  Security"}

@String{j-INT-J-PARALLEL-PROG   = "International Journal of Parallel
                                  Programming"}

@String{j-INT-J-ROBOTICS-AUTOMATION = "International Journal of Robotics and
                                  Automation"}

@String{j-INT-J-SOFTW-TOOLS-TECHNOL-TRANSFER = "International Journal on
                                  Software Tools for Technology Transfer
                                  (STTT)"}

@String{j-INT-J-SYST-SCI        = "International Journal of Systems Science"}

@String{j-INTEL-TECH-J          = "Intel Technology Journal"}

@String{j-J-ACM                 = "Journal of the ACM"}

@String{j-J-AUTOM-REASON        = "Journal of Automated Reasoning"}

@String{j-J-COMP-INFO-SYS       = "The Journal of Computer Information
                                  Systems"}

@String{j-J-COMP-SCI-TECH       = "Journal of Computer Science and Technology"}

@String{j-J-COMP-SECUR          = "Journal of Computer Security"}

@String{j-J-COMP-SYS-SCI        = "Journal of Computer and System Sciences"}

@String{j-J-COMPUT-APPL-MATH      = "Journal of Computational and Applied
                                  Mathematics"}

@String{j-J-COMPUT-BIOL         = "Journal of Computational Biology"}

@String{j-J-COMPUT-GRAPH-STAT   = "Journal of Computational and Graphical
                                  Statistics"}

@String{j-COMPUT-SECUR          = "Computers \& Security"}

@String{j-J-CRYPTO-ENG          = "Journal of Cryptographic Engineering"}

@String{j-J-DIGITAL-IMAGING     = "Journal of Digital Imaging"}

@String{j-J-FUNCT-PROGRAM       = "Journal of Functional Programming"}

@String{j-J-GEOPHYS-RES         = "Journal of Geophysical Research"}

@String{j-J-GRID-COMP           = "Journal of Grid Computing"}

@String{j-J-INFO-SEC-APPL =     "Journal of Information Security and
                                 Applications (JISA)"}

@String{j-J-INFO-SCI-ENG        = "Journal of Information Science and
                                  Engineering"}

@String{j-J-LOGIC-ALG-PROG      = "Journal of Logic and Algebraic Programming"}

@String{j-J-NETW-COMPUT-APPL    = "Journal of Network and Computer
                                  Applications"}

@String{j-J-OPEN-RES-SOFT       = "Journal of Open Research Software"}

@String{j-J-OPEN-SOURCE-SOFT    = "Journal of Open Source Software"}

@String{j-J-OPER-RES-SOC        = "OR: the journal of the Operational Research
                                  Society"}

@String{j-J-PAR-DIST-COMP       = "Journal of Parallel and Distributed
                                  Computing"}

@String{j-J-SOFTW-EVOL-PROC     = "Journal of Software: Evolution and Process"}

@String{j-J-SOFTW-MAINT-EVOL    = "Journal of Software Maintenance and
                                  Evolution: Research and Practice"}

@String{j-J-STAT-SOFT           = "Journal of Statistical Software"}

@String{j-J-SUPERCOMPUTING      = "The Journal of Supercomputing"}

@String{j-J-SYST-SOFTW          = "The Journal of systems and software"}

@String{j-J-UCS                 = "J.UCS: Journal of Universal Computer
                                  Science"}

@String{j-JERIC                 = "ACM Journal on Educational Resources in
                                  Computing (JERIC)"}

@String{j-LECT-NOTES-COMP-SCI   = "Lecture Notes in Computer Science"}

@String{j-LINUX-J               = "Linux Journal"}

@String{j-LIT-LING-COMP         = "Literary and Linguistic Computing"}

@String{j-LOGIN                 = ";login: the USENIX Association newsletter"}

@String{j-LOPLAS                = "ACM Letters on Programming Languages and
                                  Systems"}

@String{j-MAGMA                 = "Magma"}

@String{j-MARKUP-LANG           = "Markup languages: theory \& practice"}

@String{j-MATH-COMP-EDU         = "Mathematics and computer education"}

@String{j-MICROPROC-MICROSYS    = "Microprocessors and Microsystems"}

@String{j-MICROPROC-REP         = "Microprocessor report"}

@String{j-MINI-MICRO-SYSTEMS    = "Mini-Micro Systems"}

@String{j-MOL-SIM               = "Molecular simulation"}

@String{j-MULTIMEDIA-SYSTEMS    = "Multimedia Systems"}

@String{j-MULTIMEDIA-TOOLS-APPLIC = "Multimedia Tools and Applications"}

@String{j-NETWORK-COMPUTING     = "Network Computing"}

@String{j-NETWORK-SECURITY      = "Network Security"}

@String{j-NEUROIMAGE            = "NeuroImage"}

@String{j-NORDIC-J-COMPUT       = "Nordic Journal of Computing"}

@String{j-OPER-SYS-REV          = "Operating Systems Review"}

@String{j-PACMHCI               = "Proceedings of the ACM on Human-Computer
                                   Interaction (PACMHCI)"}

@String{j-PACMPL                = "Proceedings of the ACM on Programming
                                   Languages (PACMPL)"}

@String{j-PARALLEL-ALGORITHMS-APPL = "Parallel Algorithms and Applications"}

@String{j-PARALLEL-COMPUTING    = "Parallel Computing"}

@String{j-PARALLEL-DIST-COMP-PRACT = "Parallel and Distributed Computing
                                  Practices"}

@String{j-PARALLEL-PROCESS-LETT = "Parallel Processing Letters"}

@String{j-PC-MAGAZINE           = "PC Magazine"}

@String{j-PERF-EVAL             = "Performance evaluation"}

@String{j-PERS-COMPUT-WORLD     = "Personal computer world"}

@String{j-PRIMUS                = "PRIMUS (Problems Resources and Issues in
                                  Mathematics Undergraduate Studies)"}

@String{j-PROC-AM-CONTROL-CONF  = "Proceedings of the American Control
                                  Conference"}

@String{j-PROC-IEEE             = "Proceedings of the IEEE"}

@String{j-PROC-SPIE             = "Proceedings of the SPIE --- The
                                  International Society for Optical
                                  Engineering"}

@String{j-PROC-VLDB-ENDOWMENT   = "Proceedings of the VLDB Endowment"}

@String{j-PROG-COMP-SOFT        = "Programming and Computer Software;
                                  translation of Programmirovaniye (Moscow,
                                  USSR) Plenum"}

@String{j-QUEUE                 = "ACM Queue: Tomorrow's Computing Today"}

@String{j-REAL-TIME-SYST        = "Real-Time Systems"}

@String{j-REV-ESP-ELECT         = "Revista espa{\~n}ola de electronica"}

@String{j-SCI-COMPUT-PROGRAM    = "Science of Computer Programming"}

@String{j-SCI-PROG              = "Scientific Programming"}

@String{j-SCPE                  = "Scalable Computing: Practice and Experience"}

@String{j-SIGADA-LETTERS        = "ACM SIGADA Ada Letters"}

@String{j-SIGAPP                = "ACM SIGAPP Applied Computing Review"}

@String{j-SIGCSE                = "SIGCSE Bulletin (ACM Special Interest Group
                                  on Computer Science Education)"}

@String{j-SIGMETRICS            = "ACM SIGMETRICS Perform. Eval. Rev."}

@String{j-SIGMOD                = "SIGMOD Record (ACM Special Interest Group
                                  on Management of Data)"}

@String{j-SIGPLAN               = "ACM SIG{\-}PLAN Notices"}

@String{j-SIGSAM                = "SIGSAM Bulletin (ACM Special Interest Group
                                  on Symbolic and Algebraic Manipulation)"}

@String{j-SIGSOFT               = "ACM SIGSOFT Software Engineering Notes"}

@String{j-SIM-SERIES            = "Simulation series"}

@String{j-SIMULATION            = "Simulation"}

@String{j-SOFTWAREX             = "SoftwareX"}

@String{j-SPE                   = "Soft\-ware\emdash Prac\-tice and
                                  Experience"}

@String{j-SYS-ADMIN             = "SysAdmin"}

@String{j-SYS-COMP-JAPAN        = "Systems and computers in Japan"}

@String{j-SYST-CONTROL-INFO     = "Systems, Control and Information =
                                  Shisutemu Seigyo Joho Gakkai shi"}

@String{j-TAAS                  = "ACM Transactions on Autonomous and
                                  Adaptive Systems (TAAS)"}

@String{j-TACO                  = "ACM Transactions on Architecture and Code
                                  Optimization"}

@String{j-TALG                  = "ACM Transactions on Algorithms"}

@String{j-TAP                   = "ACM Transactions on Applied Perception"}

@String{j-TCBB                  = "IEEE/ACM Transactions on Computational
                                  Biology and Bioinformatics"}

@String{j-TECHNIQUE-SCI-INFORMATIQUES = "Technique et science informatiques :
                                  TSI"}

@String{j-TECS                  = "ACM Transactions on Embedded Computing
                                  Systems"}

@String{j-THEOR-COMP-SCI        = "Theoretical Computer Science"}

@String{j-TISSEC                = "ACM Transactions on Information and System
                                  Security"}

@String{j-TIST                 = "ACM Transactions on Intelligent Systems and
                                  Technology (TIST)"}

@String{j-TMIS                  = "ACM Transactions on Management Information
                                  Systems (TMIS)"}

@String{j-TOCE                  = "ACM Transactions on Computing Education"}

@String{j-TOCHI                 = "ACM Transactions on Computer-Human
                                  Interaction"}

@String{j-TOCL                  = "ACM Transactions on Computational Logic"}

@String{j-TOCS                  = "ACM Transactions on Computer Systems"}

@String{j-TODAES                = "ACM Transactions on Design Automation of
                                   Electronic Systems"}

@String{j-TOIT                  = "ACM Transactions on Internet Technology (TOIT)"}

@String{j-TOMACS                = "ACM Transactions on Modeling and
                                  Computer Simulation"}

@String{j-TOMPECS               = "ACM Transactions on Modeling and Performance
                                  Evaluation of Computing Systems (TOMPECS)"}

@String{j-TOMS                  = "ACM Transactions on Mathematical Software"}

@String{j-TOPC                  = "ACM Transactions on Parallel Computing
                                  (TOPC)"}

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

@String{j-TOPS                  = "ACM Transactions on Privacy and Security
                                  (TOPS)"}

@String{j-TOS                   = "ACM Transactions on Storage"}

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

@String{j-TWEB                  = "ACM Transactions on the Web (TWEB)"}

@String{j-VLDB-J                = "VLDB Journal: Very Large Data Bases"}

@String{j-WIRTSCHAFTSINFORMATIK = "Wirtschaftsinformatik"}

%%% ====================================================================
%%% Publishers and their addresses:

@String{pub-ACM                 = "ACM Press"}
@String{pub-ACM:adr             = "New York, NY 10036, USA"}

@String{pub-AIP                 = "American Institute of Physics"}
@String{pub-AIP:adr             = "Woodbury, NY, USA"}

@String{pub-APRESS              = "Apress"}
@String{pub-APRESS:adr          = "Berkeley, CA, USA"}

@String{pub-ARTECH              = "Artech House Inc."}
@String{pub-ARTECH:adr          = "Norwood, MA, USA"}

@String{pub-AW                  = "Ad{\-d}i{\-s}on-Wes{\-l}ey"}
@String{pub-AW:adr              = "Reading, MA, USA"}

@String{pub-AW-LONGMAN          = "Ad{\-d}i{\-s}on-Wes{\-l}ey Longman"}
@String{pub-AW-LONGMAN:adr      = "Reading, MA, USA"}

@String{pub-BIRKHAUSER          = "Birkh{\"a}user Verlag"}
@String{pub-BIRKHAUSER:adr      = "Basel, Switzerland"}

@String{pub-BROOKS-COLE         = "Brooks\slash Cole"}
@String{pub-BROOKS-COLE:adr     = "Pacific Grove, CA, USA"}

@String{pub-CAMBRIDGE           = "Cambridge University Press"}
@String{pub-CAMBRIDGE:adr       = "Cambridge, UK"}

@String{pub-CHAPMAN-HALL-CRC    = "Chapman and Hall/CRC"}
@String{pub-CHAPMAN-HALL-CRC:adr = "Boca Raton, FL, USA"}

@String{pub-CHARLES-RIVER-MEDIA = "Charles River Media, Inc."}
@String{pub-CHARLES-RIVER-MEDIA:adr = "403 VFW Drive, PO Box 417, Rockland, MA
                                  02370, USA"}

@String{pub-CORIOLIS            = "Coriolis Group Books"}
@String{pub-CORIOLIS:adr        = "Scottsdale, AZ, USA"}

@String{pub-COURSE-TECHNOLOGY   = "Course Technology"}
@String{pub-COURSE-TECHNOLOGY:adr = "Cambridge, MA, USA"}

@String{pub-CRC                 = "CRC Press"}
@String{pub-CRC:adr             = "2000 N.W. Corporate Blvd., Boca Raton, FL
                                  33431-9868, USA"}

@String{pub-HUNGRY-MINDS        = "Hungry Minds"}
@String{pub-HUNGRY-MINDS:adr    = "909 Third Avenue, New York, NY 10022, USA"}

@String{pub-HUNGRY-MINDS-IN     = "Hungry Minds"}
@String{pub-HUNGRY-MINDS-IN:adr = "Indianapolis, IN, USA"}

@String{pub-IBM-PRESS           = "IBM Press"}
@String{pub-IBM-PRESS:adr       = ""}

@String{pub-IDG                 = "IDG Books"}
@String{pub-IDG:adr             = "San Mateo, CA, USA"}

@String{pub-IDG-WORLDWIDE       = "I D G Books Worldwide"}
@String{pub-IDG-WORLDWIDE:adr   = "Indianapolis, IN, USA"}

@String{pub-IEEE                = "IEEE Computer Society Press"}
@String{pub-IEEE:adr            = "1109 Spring Street, Suite 300, Silver
                                  Spring, MD 20910, USA"}

@String{pub-IOS                 = "IOS Press"}
@String{pub-IOS:adr             = "Amsterdam, The Netherlands"}

@String{pub-IRWIN-MCGRAW-HILL   = "Irwin\slash McGraw Hill"}
@String{pub-IRWIN-MCGRAW-HILL:adr = "Boston, MA, USA"}

@String{pub-ISO                 = "International Organization for Standardization"}
@String{pub-ISO:adr             = "Geneva, Switzerland"}

@String{pub-ITP                 = "International Thomson Publishing"}
@String{pub-ITP:adr             = "London, New York, Boston, Madrid,
                                  \\ldots{}"}

@String{pub-JONES-BARTLETT      = "Jones and Bartlett"}
@String{pub-JONES-BARTLETT:adr  = "Boston, MA, USA"}

@String{pub-KLUWER              = "Kluwer Academic Publishers Group"}
@String{pub-KLUWER:adr          = "Norwell, MA, USA, and Dordrecht, The
                                  Netherlands"}

@String{pub-MANNING             = "Manning Publications"}
@String{pub-MANNING:adr         = "Greenwich, CT, USA"}

@String{pub-MCGRAW-HILL         = "Mc{\-}Graw-Hill"}
@String{pub-MCGRAW-HILL:adr     = "New York, NY, USA"}

@String{pub-MIT                 = "MIT Press"}
@String{pub-MIT:adr             = "Cambridge, MA, USA"}

@String{pub-MORGAN-KAUFMANN     = "Morgan Kaufmann Publishers"}
@String{pub-MORGAN-KAUFMANN:adr = "Los Altos, CA 94022, USA"}

@String{pub-MT                  = "M\&T Books"}
@String{pub-MT:adr              = "M\&T Publishing, Inc., 501 Galveston Drive,
                                  Redwood City, CA 94063, USA"}

@String{pub-NASA                = "National Aeronautics and Space
                                  Administration"}
@String{pub-NASA:adr            = "Washington, DC, USA"}

@String{pub-NEW-RIDERS          = "New Riders Publishing"}
@String{pub-NEW-RIDERS:adr      = "Carmel, IN, USA"}

@String{pub-NIST                = "National Institute for Standards and
                                  Technology"}
@String{pub-NIST:adr            = "Gaithersburg, MD, USA"}

@String{pub-NO-STARCH           = "No Starch Press"}
@String{pub-NO-STARCH:adr       = "San Francisco, CA, USA"}

@String{pub-NORTON              = "W. W. Norton \& Co."}
@String{pub-NORTON:adr          = "New York, NY, USA"}

@String{pub-ORA                 = "O'Reilly \& {Associates, Inc.}"}
@String{pub-ORA:adr             = "981 Chestnut Street, Newton, MA 02164, USA"}

@String{pub-ORA-MEDIA           = "O'Reilly Media, Inc."}
@String{pub-ORA-MEDIA:adr       = "1005 Gravenstein Highway North, Sebastopol,
                                  CA 95472, USA"}

@String{pub-OSBORNE             = "Osborne/McGraw-Hill"}
@String{pub-OSBORNE:adr         = "Berkeley, CA, USA"}

@String{pub-PACKT               = "Packt Publishing"}
@String{pub-PACKT:adr           = "Birmingham"}

@String{pub-PEACHPIT            = "Peachpit Press, Inc."}
@String{pub-PEACHPIT:adr        = "1085 Keith Avenue, Berkeley, CA 94708, USA"}

@String{pub-PEARSON-EDUCATION   = "Pearson Education"}
@String{pub-PEARSON-EDUCATION:adr = "Upper Saddle River, NJ, USA"}

@String{pub-PH                  = "Pren{\-}tice-Hall"}
@String{pub-PH:adr              = "Englewood Cliffs, NJ 07632, USA"}

@String{pub-PHPTR               = "P T R Pren{\-}tice-Hall"}
@String{pub-PHPTR:adr           = "Englewood Cliffs, NJ 07632, USA"}

@String{pub-PRAGMATIC-BOOKSHELF = "Pragmatic Bookshelf"}
@String{pub-PRAGMATIC-BOOKSHELF:adr = "Raleigh, NC, USA"}

@String{pub-PRINCETON           = "Princeton University Press"}
@String{pub-PRINCETON:adr       = "Princeton, NJ, USA"}

@String{pub-QUE                 = "Que Corporation"}
@String{pub-QUE:adr             = "Indianapolis, IN, USA"}

@String{pub-R-D-BOOKS           = "R\&D Books"}
@String{pub-R-D-BOOKS:adr       = "Lawrence, KS, USA; Berkeley, CA, USA"}

@String{pub-SAE                 = "Society of Automotive Engineers"}
@String{pub-SAE:adr             = "Warrendale, PA, USA"}

@String{pub-SAMS                = "Howard W. Sams"}
@String{pub-SAMS:adr            = "Indianapolis, IN 46268, USA"}

@String{pub-SCOTT-JONES         = "Scott\slash Jones"}
@String{pub-SCOTT-JONES:adr     = "El Granada, CA, USA"}

@String{pub-SIAM                = "SIAM Press"}
@String{pub-SIAM:adr            = "Philadelphia, PA, USA"}

@String{pub-SITEPOINT           = "SitePoint Pty. Ltd."}
@String{pub-SITEPOINT:adr       = "Collingwood, VIC, Australia"}

@String{pub-SPIE                = "SPIE Optical Engineering Press"}
@String{pub-SPIE:adr            = "Bellingham, WA, USA"}

@String{pub-SUN-MICROSYSTEMS-PRESS = "Sun Microsystems Press"}
@String{pub-SUN-MICROSYSTEMS-PRESS:adr = "Palo Alto, CA, USA"}

@String{pub-SUNSOFT             = "SunSoft Press"}
@String{pub-SUNSOFT:adr         = "2550 Garcia Avenue, Mountain View, CA
                                  94043-1100, USA"}

@String{pub-SV                  = "Spring{\-}er-Ver{\-}lag"}
@String{pub-SV:adr              = "Berlin, Germany~/ Heidelberg, Germany~/
                                  London, UK~/ etc."}

@String{pub-SYBEX               = "Sybex, Inc."}
@String{pub-SYBEX:adr           = "2021 Challenger Driver, Suite 100, Alameda,
                                  CA 94501, USA"}

@String{pub-USENIX              = "USENIX Association"}
@String{pub-USENIX:adr          = "Berkeley, CA, USA"}

@String{pub-WILEY               = "John Wiley and Sons"}
@String{pub-WILEY:adr           = "New York, NY, USA; London, UK; Sydney,
                                  Australia"}

@String{pub-WILEY-COMPUTER      = "Wiley Computer Publishers"}
@String{pub-WILEY-COMPUTER:adr  = "New York, NY, USA"}

@String{pub-WROX                = "Wrox Press"}
@String{pub-WROX:adr            = "Chicago, IL, USA"}

%%% ====================================================================
%%% Series abbreviations:

@String{ser-LNCS                = "Lecture Notes in Computer Science"}

@String{ser-LNCSE               = "Lecture Notes in Computational
                                   Science and Engineering"}

%%% ====================================================================
%%% Bibliography entries, sorted by year, and then by citation key.

@Book{Stark:2001:JJV,
  author =       "Robert F. St{\"a}rk and Joachim Schmid and Egon
                 B{\"o}rger",
  title =        "{Java} and the {Java Virtual Machine}: definition,
                 verification, validation",
  publisher =    pub-SV,
  address =      pub-SV:adr,
  pages =        "x + 381",
  year =         "2001",
  ISBN =         "3-540-42088-6",
  ISBN-13 =      "978-3-540-42088-0",
  LCCN =         "QA76.73.J38 S785 2001",
  bibdate =      "Mon May 6 06:26:30 MDT 2002",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/mathcw.bib",
  note =         "Includes CD-ROM with the entire text of the book and
                 numerous examples and exercises.",
  price =        "US\$49.95",
  acknowledgement = ack-nhfb,
  keywords =     "Java (computer program language); virtual computer
                 systems",
}

@Article{Akai:2010:EAS,
  author =       "Shumpei Akai and Shigeru Chiba",
  title =        "Extending {AspectJ} for separating regions",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "2",
  pages =        "45--54",
  month =        feb,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1837852.1621616",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Aug 31 22:37:56 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "Synchronization is a good candidate for an aspect in
                 aspect-oriented programming (AOP) since programmers
                 have to choose the best granularity of synchronization
                 for the underlying hardware to obtain the best
                 execution performance. If synchronization is an aspect,
                 programmers can change the synchronization code
                 independently of the rest of the program when the
                 program runs on different hardware. However, existing
                 AOP languages such as AspectJ have problems. They
                 cannot select an arbitrary code region as a join point.
                 Moreover, they cannot enforce weaving of a
                 synchronization aspect. Since it is an alternative
                 feature in feature modeling, at least one of available
                 synchronization aspects must be woven. Otherwise, the
                 program would be thread-unsafe. Since an aspect in
                 AspectJ is inherently optional, programmers must be
                 responsible for weaving it. To solve these problems,
                 this paper proposes two new constructs for AspectJ,
                 {\em regioncut\/} and {\em assertions for advice}.
                 Regioncut selects arbitrary code region as a join point
                 and assertion for advice enforces weaving a mandatory
                 advice. We implemented these constructs by extending
                 the AspectBench compiler. We evaluated the design of
                 our constructs by applying them to two open-source
                 software products, Javassist and Hadoop.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  keywords =     "aspect-oriented programming; feature-oriented
                 programming; region; synchronization",
}

@Article{Albert:2010:PIM,
  author =       "Elvira Albert and Samir Genaim and Miguel
                 G{\'o}mez-Zamalloa",
  title =        "Parametric inference of memory requirements for
                 garbage collected languages",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "8",
  pages =        "121--130",
  month =        aug,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1806651.1806671",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Oct 8 17:55:48 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "The accurate prediction of program's memory
                 requirements is a critical component in software
                 development. Existing heap space analyses either do not
                 take deallocation into account or adopt specific models
                 of garbage collectors which do not necessarily
                 correspond to the actual memory usage. We present a
                 novel approach to inferring upper bounds on memory
                 requirements of Java-like programs which is {\em
                 parametric\/} on the notion of {\em object lifetime},
                 i.e., on when objects become collectible. If objects
                 lifetimes are inferred by a reachability analysis, then
                 our analysis infers accurate upper bounds on the memory
                 consumption for a {\em reachability\/} -based garbage
                 collector. Interestingly, if objects lifetimes are
                 inferred by a {\em heap liveness\/} analysis, then we
                 approximate the program minimal memory requirement,
                 i.e., the peak memory usage when using an optimal
                 garbage collector which frees objects as soon as they
                 become dead. The key idea is to integrate information
                 on objects lifetimes into the process of generating the
                 {\em recurrence equations\/} which capture the memory
                 usage at the different program states. If the heap size
                 limit is set to the memory requirement inferred by our
                 analysis, it is ensured that execution will not exceed
                 the memory limit with the only assumption that garbage
                 collection works when the limit is reached. Experiments
                 on Java bytecode programs provide evidence of the
                 feasibility and accuracy of our analysis.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  keywords =     "garbage collection; java bytecode; live heap space
                 analysis; low-level languages; peak memory
                 consumption",
}

@Article{Ali:2010:DJB,
  author =       "Mohammed F. M. Ali and Mohammed I. Younis and Kamal Z.
                 Zamli and Widad Ismail",
  title =        "Development of {Java} based {RFID} application
                 programmable interface for heterogeneous {RFID}
                 system",
  journal =      j-J-SYST-SOFTW,
  volume =       "83",
  number =       "11",
  pages =        "2322--2331",
  month =        nov,
  year =         "2010",
  CODEN =        "JSSODM",
  ISSN =         "0164-1212 (print), 1873-1228 (electronic)",
  ISSN-L =       "0164-1212",
  bibdate =      "Mon Nov 1 11:40:40 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://www.sciencedirect.com/science/journal/01641212",
  acknowledgement = ack-nhfb,
  fjournal =     "The Journal of systems and software",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01641212",
}

@Article{Altman:2010:OTJ,
  author =       "E. Altman and M. Arnold and R. Bordawekar and R. M.
                 Delmonico and N. Mitchell and P. F. Sweeney",
  title =        "Observations on tuning a {Java} enterprise application
                 for performance and scalability",
  journal =      j-IBM-JRD,
  volume =       "54",
  number =       "5",
  pages =        "2:1--2:12",
  month =        "????",
  year =         "2010",
  CODEN =        "IBMJAE",
  DOI =          "https://doi.org/10.1147/JRD.2010.2057090",
  ISSN =         "0018-8646 (print), 2151-8556 (electronic)",
  ISSN-L =       "0018-8646",
  bibdate =      "Sun Feb 20 14:29:19 MST 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://www.research.ibm.com/journal/",
  acknowledgement = ack-nhfb,
  fjournal =     "IBM Journal of Research and Development",
  journal-URL =  "http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=5288520",
}

@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/java2010.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,
  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{Auerbach:2010:LJC,
  author =       "Joshua Auerbach and David F. Bacon and Perry Cheng and
                 Rodric Rabbah",
  title =        "{Lime}: a {Java}-compatible and synthesizable language
                 for heterogeneous architectures",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "10",
  pages =        "89--108",
  month =        oct,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1932682.1869469",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Wed Jan 26 15:13:46 MST 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Barabash:2010:TGC,
  author =       "Katherine Barabash and Erez Petrank",
  title =        "Tracing garbage collection on highly parallel
                 platforms",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "8",
  pages =        "1--10",
  month =        aug,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1837855.1806653",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Oct 8 17:55:48 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "The pervasiveness of multiprocessor and multicore
                 hardware and the rising level of available parallelism
                 are radically changing the computing landscape. Can
                 software deal with tomorrow's potential higher
                 parallelism? In this paper we study this issue from the
                 garbage collection perspective. In particular, we
                 investigate the scalability of parallel heap tracing,
                 which stands at the core of the garbage collection
                 activity. Heap shapes can be sequential in nature, and
                 prevent the collector from scaling the trace. We start
                 by proposing the idealized trace utilization as a
                 scalability measure for evaluating the scalability of a
                 given heap shape. We then examine standard Java
                 benchmarks and evaluate the existence of non-scalable
                 object-graph shapes in their execution. Next, we
                 propose and implement a prototype of garbage collection
                 techniques that attempt to ameliorate the object-graph
                 shape problem. Finally, we measure and report their
                 efficacy.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  keywords =     "garbage collection; memory management; parallel
                 garbage collection; runtime systems",
}

@Article{Barbuti:2010:AIA,
  author =       "Roberto Barbuti and Nicoletta {De Francesco} and Luca
                 Tesei",
  title =        "An Abstract Interpretation Approach for Enhancing the
                 {Java Bytecode Verifier}",
  journal =      j-COMP-J,
  volume =       "53",
  number =       "6",
  pages =        "679--700",
  month =        jul,
  year =         "2010",
  CODEN =        "CMPJA6",
  DOI =          "https://doi.org/10.1093/comjnl/bxp031",
  ISSN =         "0010-4620 (print), 1460-2067 (electronic)",
  ISSN-L =       "0010-4620",
  bibdate =      "Tue Aug 3 15:52:17 MDT 2010",
  bibsource =    "http://comjnl.oxfordjournals.org/content/vol53/issue6/index.dtl;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  note =         "This article is the winner of The Computer Journal
                 Wilkes Award for 2010.",
  URL =          "http://comjnl.oxfordjournals.org/cgi/content/abstract/53/6/679;
                 http://comjnl.oxfordjournals.org/cgi/reprint/53/6/679;
                 http://www.oxfordjournals.org/our_journals/computer_journal/wilkes_award.html",
  acknowledgement = ack-nhfb,
  fjournal =     "The Computer Journal",
  journal-URL =  "http://comjnl.oxfordjournals.org/",
}

@Article{Basanta-Val:2010:NHR,
  author =       "Pablo Basanta-Val and Marisol Garc{\'\i}a-Valls and
                 Iria Est{\'e}vez-Ayres",
  title =        "{No-Heap Remote Objects} for distributed real-time
                 {Java}",
  journal =      j-TECS,
  volume =       "10",
  number =       "1",
  pages =        "7:1--7:??",
  month =        aug,
  year =         "2010",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/1814539.1814546",
  ISSN =         "1539-9087 (print), 1558-3465 (electronic)",
  ISSN-L =       "1539-9087",
  bibdate =      "Mon Aug 30 15:29:45 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "This article presents an approach to providing
                 real-time support for Java's Remote Method Invocation
                 (RMI) and its integration with the RTSJ memory model in
                 order to leave out garbage collection. A new construct
                 for remote objects, called {\em No-heap Remote
                 object\/} ({\em NhRo\/}), is introduced. The use of a
                 NhRo guarantees that memory required to perform a
                 remote invocation (at the server side) does not use
                 heap memory. Thus, the aim is to avoid garbage
                 collection in the remote invocation process, improving
                 predictability and memory isolation of distributed
                 Java-based real-time applications. The article presents
                 the bare model and the main programming patterns that
                 are associated with the NhRo model. Sun RMI
                 implementation has been modified to integrate the NhRo
                 model in both static and dynamic environments.",
  acknowledgement = ack-nhfb,
  articleno =    "7",
  fjournal =     "ACM Transactions on Embedded Computing Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?&idx=J840",
  keywords =     "distributed real-time Java; DRTSJ; Real-time Java;
                 real-time remote objects; region-based memory
                 management; RTSJ",
}

@Article{Basanta-Val:2010:SSS,
  author =       "Pablo Basanta-Val and Iria Estevez-Ayres and Marisol
                 Garcia-Valls and Luis Almeida",
  title =        "A Synchronous Scheduling Service for Distributed
                 Real-Time {Java}",
  journal =      j-IEEE-TRANS-PAR-DIST-SYS,
  volume =       "21",
  number =       "4",
  pages =        "506--519",
  month =        apr,
  year =         "2010",
  CODEN =        "ITDSEO",
  DOI =          "https://doi.org/10.1109/TPDS.2009.95",
  ISSN =         "1045-9219 (print), 1558-2183 (electronic)",
  ISSN-L =       "1045-9219",
  bibdate =      "Thu May 13 12:06:56 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE Transactions on Parallel and Distributed
                 Systems",
  journal-URL =  "http://www.computer.org/tpds/archives.htm",
}

@Article{Bebenita:2010:STB,
  author =       "Michael Bebenita and Florian Brandner and Manuel
                 Fahndrich and Francesco Logozzo and Wolfram Schulte and
                 Nikolai Tillmann and Herman Venter",
  title =        "{SPUR}: a trace-based {JIT} compiler for {CIL}",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "10",
  pages =        "708--725",
  month =        oct,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1932682.1869517",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Wed Jan 26 15:13:46 MST 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Bodden:2010:AOR,
  author =       "E. Bodden and K. Havelund",
  title =        "Aspect-Oriented Race Detection in {Java}",
  journal =      j-IEEE-TRANS-SOFTW-ENG,
  volume =       "36",
  number =       "4",
  pages =        "509--527",
  month =        jul # "\slash " # aug,
  year =         "2010",
  CODEN =        "IESEDJ",
  DOI =          "https://doi.org/10.1109/TSE.2010.25",
  ISSN =         "0098-5589 (print), 1939-3520 (electronic)",
  ISSN-L =       "0098-5589",
  bibdate =      "Thu Feb 1 19:49:24 MST 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ieeetranssoftweng2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=5406531",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE Transactions on Software Engineering",
  journal-URL =  "http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=32",
}

@Article{Ceccato:2010:MLD,
  author =       "Mariano Ceccato and Thomas Roy Dean and Paolo Tonella
                 and Davide Marchignoli",
  title =        "Migrating legacy data structures based on variable
                 overlay to {Java}",
  journal =      j-J-SOFTW-MAINT-EVOL,
  volume =       "22",
  number =       "3",
  pages =        "211--237",
  month =        apr,
  year =         "2010",
  CODEN =        "JSMECT",
  DOI =          "https://doi.org/10.1002/smr.418",
  ISSN =         "1532-060X (print), 1532-0618 (electronic)",
  ISSN-L =       "1532-060X",
  bibdate =      "Wed Jan 31 10:00:28 MST 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/jsoftwmaintevol.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Software Maintenance and Evolution:
                 Research and Practice",
  journal-URL =  "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)2047-7481",
}

@Article{Chalin:2010:TIG,
  author =       "Patrice Chalin and Robby and Perry R. James and
                 Jooyong Lee and George Karabotsos",
  title =        "Towards an industrial grade {IVE} for {Java} and next
                 generation research platform for {JML}",
  journal =      j-INT-J-SOFTW-TOOLS-TECHNOL-TRANSFER,
  volume =       "12",
  number =       "6",
  pages =        "429--446",
  month =        nov,
  year =         "2010",
  CODEN =        "????",
  ISSN =         "1433-2779 (print), 1433-2787 (electronic)",
  ISSN-L =       "1433-2779",
  bibdate =      "Tue Sep 6 22:15:47 MDT 2011",
  bibsource =    "http://springerlink.metapress.com/openurl.asp?genre=issue&issn=1433-2779&volume=12&issue=6;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://www.springerlink.com/openurl.asp?genre=article&issn=1433-2779&volume=12&issue=6&spage=429",
  acknowledgement = ack-nhfb,
  fjournal =     "International Journal on Software Tools for Technology
                 Transfer: STTT",
}

@Article{Chambers:2010:FEE,
  author =       "Craig Chambers and Ashish Raniwala and Frances Perry
                 and Stephen Adams and Robert R. Henry and Robert
                 Bradshaw and Nathan Weizenbaum",
  title =        "{FlumeJava}: easy, efficient data-parallel pipelines",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "6",
  pages =        "363--375",
  month =        jun,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1809028.1806638",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Oct 8 17:53:18 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "MapReduce and similar systems significantly ease the
                 task of writing data-parallel code. However, many
                 real-world computations require a pipeline of
                 MapReduces, and programming and managing such pipelines
                 can be difficult. We present FlumeJava, a Java library
                 that makes it easy to develop, test, and run efficient
                 data-parallel pipelines. At the core of the FlumeJava
                 library are a couple of classes that represent
                 immutable parallel collections, each supporting a
                 modest number of operations for processing them in
                 parallel. Parallel collections and their operations
                 present a simple, high-level, uniform abstraction over
                 different data representations and execution
                 strategies. To enable parallel operations to run
                 efficiently, FlumeJava defers their evaluation, instead
                 internally constructing an execution plan dataflow
                 graph. When the final results of the parallel
                 operations are eventually needed, FlumeJava first
                 optimizes the execution plan, and then executes the
                 optimized operations on appropriate underlying
                 primitives (e.g., MapReduces). The combination of
                 high-level abstractions for parallel data and
                 computation, deferred evaluation and optimization, and
                 efficient parallel primitives yields an easy-to-use
                 system that approaches the efficiency of hand-optimized
                 pipelines. FlumeJava is in active use by hundreds of
                 pipeline developers within Google.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  keywords =     "data-parallel programming; java; mapreduce",
}

@Article{Costa:2010:RMN,
  author =       "Gabriele Costa and Fabio Martinelli and Paolo Mori and
                 Christian Schaefer and Thomas Walter",
  title =        "Runtime monitoring for next generation {Java ME}
                 platform",
  journal =      j-COMPUT-SECUR,
  volume =       "29",
  number =       "1",
  pages =        "74--87",
  month =        feb,
  year =         "2010",
  CODEN =        "CPSEDU",
  ISSN =         "0167-4048 (print), 1872-6208 (electronic)",
  ISSN-L =       "0167-4048",
  bibdate =      "Mon Sep 23 09:46:19 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/computsecur2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "https://www.sciencedirect.com/science/article/pii/S0167404809000790",
  acknowledgement = ack-nhfb,
  fjournal =     "Computers \& Security",
  journal-URL =  "https://www.sciencedirect.com/science/journal/01674048",
}

@Article{Curley:2010:RDT,
  author =       "Edward Curley and Binoy Ravindran and Jonathan
                 Anderson and E. Douglas Jensen",
  title =        "Recovering from distributable thread failures in
                 distributed real-time {Java}",
  journal =      j-TECS,
  volume =       "10",
  number =       "1",
  pages =        "8:1--8:??",
  month =        aug,
  year =         "2010",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/1814539.1814547",
  ISSN =         "1539-9087 (print), 1558-3465 (electronic)",
  ISSN-L =       "1539-9087",
  bibdate =      "Mon Aug 30 15:29:45 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "We consider the problem of recovering from the
                 failures of distributable threads (``threads'') in
                 distributed real-time systems that operate under
                 runtime uncertainties including those on thread
                 execution times, thread arrivals, and node failure
                 occurrences. When a thread experiences a node failure,
                 the result is a broken thread having an orphan. Under a
                 termination model, the orphans must be detected and
                 aborted, and exceptions must be delivered to the
                 farthest, contiguous surviving thread segment for
                 resuming thread execution. Our application/scheduling
                 model includes the proposed distributable thread
                 programming model for the emerging Distributed
                 Real-Time Specification for Java (DRTSJ), together with
                 an exception-handler model. Threads are subject to
                 time/utility function (TUF) time constraints and an
                 utility accrual (UA) optimality criterion. A key
                 underpinning of the TUF/UA scheduling paradigm is the
                 notion of ``best-effort'' where higher importance
                 threads are always favored over lower importance ones,
                 irrespective of thread urgency as specified by their
                 time constraints. We present a thread scheduling
                 algorithm called HUA and a thread integrity protocol
                 called TPR. We show that HUA and TPR bound the orphan
                 cleanup and recovery time with bounded loss of the
                 best-effort property. Our implementation experience for
                 HUA/TPR in the Reference Implementation of the proposed
                 programming model for the DRTSJ demonstrates the
                 algorithm/protocol's effectiveness.",
  acknowledgement = ack-nhfb,
  articleno =    "8",
  fjournal =     "ACM Transactions on Embedded Computing Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?&idx=J840",
  keywords =     "distributable thread; Distributed; distributed
                 scheduling; Java; real-time; thread integrity",
}

@Article{Dam:2010:PCI,
  author =       "Mads Dam and Bart Jacobs and Andreas Lundblad and
                 Frank Piessens",
  title =        "Provably correct inline monitoring for multithreaded
                 {Java}-like programs",
  journal =      j-J-COMP-SECUR,
  volume =       "18",
  number =       "1",
  pages =        "37--59",
  month =        "????",
  year =         "2010",
  CODEN =        "JCSIET",
  DOI =          "https://doi.org/10.3233/JCS-2010-0365",
  ISSN =         "0926-227X (print), 1875-8924 (electronic)",
  ISSN-L =       "0926-227X",
  bibdate =      "Tue May 24 06:24:34 MDT 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/jcompsecur.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Computer Security",
  journal-URL =  "http://content.iospress.com/journals/journal-of-computer-security",
}

@Article{DeFrancesco:2010:UAI,
  author =       "Nicoletta {De Francesco} and Giuseppe Lettieri and
                 Luca Martini",
  title =        "Using abstract interpretation to add type checking for
                 interfaces in {Java} bytecode verification",
  journal =      j-THEOR-COMP-SCI,
  volume =       "411",
  number =       "22--24",
  pages =        "2174--2201",
  day =          "17",
  month =        may,
  year =         "2010",
  CODEN =        "TCSCDI",
  ISSN =         "0304-3975 (print), 1879-2294 (electronic)",
  ISSN-L =       "0304-3975",
  bibdate =      "Mon Mar 28 17:10:32 MDT 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://www.sciencedirect.com/science/journal/03043975",
  abstract =     "Java interface types support multiple inheritance.
                 Because of this, the standard bytecode verifier ignores
                 them, since it is not able to model the class hierarchy
                 as a lattice. Thus, type checks on interfaces are
                 performed at run time. We propose a verification
                 methodology that removes the need for run-time checks.
                 The methodology consists of: (1) an augmented verifier
                 that is very similar to the standard one, but is also
                 able to check for interface types in most cases; (2)
                 for all other cases, a set of additional simpler
                 verifiers, each one specialized for a single interface
                 type. We obtain these verifiers in a systematic way by
                 using abstract interpretation techniques. Finally, we
                 describe an implementation of the methodology and
                 evaluate it on a large set of benchmarks.",
  acknowledgement = ack-nhfb,
  fjournal =     "Theoretical Computer Science",
  journal-URL =  "http://www.sciencedirect.com/science/journal/03043975",
}

@Article{Deitcher:2010:JEJ,
  author =       "Avi Deitcher",
  title =        "{JSormdb} --- an embedded {JavaScript} database",
  journal =      j-LINUX-J,
  volume =       "2010",
  number =       "192",
  pages =        "4:1--4:??",
  month =        apr,
  year =         "2010",
  CODEN =        "LIJOFX",
  ISSN =         "1075-3583 (print), 1938-3827 (electronic)",
  ISSN-L =       "1075-3583",
  bibdate =      "Tue Nov 23 11:41:54 MST 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  articleno =    "4",
  fjournal =     "Linux Journal",
  journal-URL =  "http://portal.acm.org/citation.cfm?id=J508",
}

@Article{Dietrich:2010:POD,
  author =       "K. Dietrich and F. R{\"o}ck",
  title =        "Performance Optimizations for {DAA} Signatures on
                 {Java} enabled Platforms",
  journal =      j-J-UCS,
  volume =       "16",
  number =       "4",
  pages =        "519--??",
  month =        "????",
  year =         "2010",
  CODEN =        "????",
  ISSN =         "0948-6968",
  ISSN-L =       "0948-6968",
  bibdate =      "Wed Aug 25 21:53:00 MDT 2010",
  bibsource =    "http://www.jucs.org/jucs;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://www.jucs.org/jucs_16_4/performance_optimizations_for_daa",
  acknowledgement = ack-nhfb,
  fjournal =     "J.UCS: Journal of Universal Computer Science",
  journal-URL =  "http://www.jucs.org/jucs",
}

@Article{DosSantos:2010:MPB,
  author =       "Osmar Marchi {Dos Santos} and Andy Wellings",
  title =        "Measuring and policing blocking times in real-time
                 systems",
  journal =      j-TECS,
  volume =       "10",
  number =       "1",
  pages =        "2:1--2:??",
  month =        aug,
  year =         "2010",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/1814539.1814541",
  ISSN =         "1539-9087 (print), 1558-3465 (electronic)",
  ISSN-L =       "1539-9087",
  bibdate =      "Mon Aug 30 15:29:45 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "In real-time systems, the execution-time overrun of a
                 thread may lead to a deadline being missed by the
                 thread or even others threads in the system. From a
                 fault tolerance perspective, both execution time
                 overruns and deadline misses can be considered timing
                 errors that could potentially cause a failure in the
                 system's ability to deliver its services in a timely
                 manner. In this context, the ideal is to detect the
                 error in the system as soon as possible, so that the
                 propagation of the error can be limited and error
                 recovery strategies can take place with more accurate
                 information. The run-time support mechanism usually
                 deployed for monitoring the timing requirements of
                 real-time systems is based on deadline monitoring, that
                 is, the system calls specific application code whenever
                 a deadline is violated. Recognizing that deadline
                 monitoring may not be enough for providing an adequate
                 level of fault tolerance for timing errors, major
                 real-time programming standards, like Ada, POSIX and
                 the Real-Time Specification for Java (RTSJ), have
                 proposed different mechanisms for monitoring the
                 execution time of threads. Nevertheless, in order to
                 provide a complete fault tolerance approach for timing
                 errors, the potential blocking time of threads also has
                 to be monitored. In this article, we propose mechanisms
                 for measuring and policing the blocking time of threads
                 in the context of both {\em basic priority
                 inheritance\/} and {\em priority ceiling protocols}.
                 The notion of {\em blocking-time clocks and timers\/}
                 for the POSIX standard is proposed, implemented and
                 evaluated in the open-source real-time operating system
                 MaRTE OS. Also, a {\em blocking time monitoring
                 model\/} for measuring and policing blocking times in
                 the RTSJ framework is specified. This model is
                 implemented and evaluated in the (RTSJ-compliant)
                 open-source middleware jRate, running on top of MaRTE
                 OS.",
  acknowledgement = ack-nhfb,
  articleno =    "2",
  fjournal =     "ACM Transactions on Embedded Computing Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?&idx=J840",
  keywords =     "error detection; POSIX standard; Real-time
                 specification for Java; timing errors",
}

@Article{Egbring:2010:POS,
  author =       "Marco Egbring and Gerd A. Kullak-Ublick and Stefan
                 Russmann",
  title =        "{Phynx}: an open source software solution supporting
                 data management and web-based patient-level data review
                 for drug safety studies in the general practice
                 research database and other health care databases",
  journal =      "Pharmacoepidemiology and Drug Safety",
  volume =       "19",
  number =       "1",
  pages =        "38--44",
  year =         "2010",
  DOI =          "https://doi.org/10.1002/pds.1860",
  ISSN =         "1053-8569 (print), 1099-1557 (electronic)",
  ISSN-L =       "1053-8569",
  bibdate =      "Tue Jan 30 07:39:48 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/gnu.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Adobe Flex 3, Apache Tomcat, claims databases,
                 Eclipse, electronic medical records, general practice
                 research database (GPRD), Internet, Java, MySQL,
                 pharmacoepidemiology, Talend Open Studio, validation",
}

@Article{Elmas:2010:GRA,
  author =       "Tayfun Elmas and Shaz Qadeer and Serdar Tasiran",
  title =        "{Goldilocks}: a race-aware {Java} runtime",
  journal =      j-CACM,
  volume =       "53",
  number =       "11",
  pages =        "85--92",
  month =        nov,
  year =         "2010",
  CODEN =        "CACMA2",
  DOI =          "https://doi.org/10.1145/1839676.1839698",
  ISSN =         "0001-0782 (print), 1557-7317 (electronic)",
  ISSN-L =       "0001-0782",
  bibdate =      "Fri Oct 29 17:02:13 MDT 2010",
  bibsource =    "http://www.acm.org/pubs/contents/journals/cacm/;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Communications of the ACM",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J79",
}

@Article{Flanagan:2010:AMD,
  author =       "Cormac Flanagan and Stephen N. Freund",
  title =        "Adversarial memory for detecting destructive races",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "6",
  pages =        "244--254",
  month =        jun,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1806596.1806625",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Oct 8 17:53:18 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "Multithreaded programs are notoriously prone to race
                 conditions, a problem exacerbated by the widespread
                 adoption of multi-core processors with complex memory
                 models and cache coherence protocols. Much prior work
                 has focused on static and dynamic analyses for race
                 detection, but these algorithms typically are unable to
                 distinguish destructive races that cause erroneous
                 behavior from benign races that do not. Performing this
                 classification manually is difficult, time consuming,
                 and error prone.\par

                 This paper presents a new dynamic analysis technique
                 that uses {\em adversarial memory\/} to classify race
                 conditions as destructive or benign on systems with
                 relaxed memory models. Unlike a typical language
                 implementation, which may only infrequently exhibit
                 non-sequentially consistent behavior, our adversarial
                 memory implementation exploits the full freedom of the
                 memory model to return older, unexpected, or stale
                 values for memory reads whenever possible, in an
                 attempt to crash the target program (that is, to force
                 the program to behave erroneously). A crashing
                 execution provides concrete evidence of a destructive
                 bug, and this bug can be strongly correlated with a
                 specific race condition in the target
                 program.\par

                 Experimental results with our Jumble prototype for Java
                 demonstrate that adversarial memory is highly effective
                 at identifying destructive race conditions, and in
                 distinguishing them from race conditions that are real
                 but benign. Adversarial memory can also reveal
                 destructive races that would not be detected by
                 traditional testing (even after thousands of runs) or
                 by model checkers that assume sequential consistency.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  keywords =     "concurrency; dynamic analysis; race conditions;
                 relaxed memory models",
}

@Article{Gama:2010:SAA,
  author =       "Kiev Gama and Didier Donsez",
  title =        "A survey on approaches for addressing dependability
                 attributes in the {OSGi} service platform",
  journal =      j-SIGSOFT,
  volume =       "35",
  number =       "3",
  pages =        "1--8",
  month =        may,
  year =         "2010",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/1764810.1764818",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:15:53 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  abstract =     "The OSGi service platform is being used in software
                 industry as the de facto middleware for developing and
                 deploying modular Java applications, using SOA
                 principles in centralized solutions. OSGi provides a
                 dynamic platform where components and services can be
                 deployed and undeployed at runtime, attracting the
                 attention of both commercial and research projects.
                 Although the platform is used in fields with different
                 purposes (e.g. experimentally used in healthcare,
                 commercially used in application servers) but where
                 dependability should be a pre-requisite for
                 applications, it is a fact that the OSGi technology
                 does not provide a dependable platform for executing
                 applications with such needs. Different research
                 efforts try to address dependability attributes
                 (availability, integrity, maintainability, reliability,
                 safety, and confidentiality) in the OSGi service
                 platform, but not necessarily all of these attributes
                 are completely covered or explicitly addressed in the
                 textual references. We provide a brief survey on recent
                 research efforts that try to improve dependability in
                 the OSGi service platform. We analyze and identify
                 which attributes are addressed on each approach, and
                 provide a discussion on the employed techniques,
                 similarities and results achieved on such approaches.
                 Al-though this survey remains limited to one technology
                 (OSGi), the problematic as well as all the employed
                 techniques in the analyzed efforts are pertinent to
                 other service and component-based systems.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Geoffray:2010:VSM,
  author =       "Nicolas Geoffray and Ga{\"e}l Thomas and Julia Lawall
                 and Gilles Muller and Bertil Folliot",
  title =        "{VMKit}: a substrate for managed runtime
                 environments",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "7",
  pages =        "51--62",
  month =        jul,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1735997.1736006",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Oct 8 17:55:01 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "Managed Runtime Environments (MREs), such as the JVM
                 and the CLI, form an attractive environment for program
                 execution, by providing portability and safety, via the
                 use of a bytecode language and automatic memory
                 management, as well as good performance, via
                 just-in-time (JIT) compilation. Nevertheless,
                 developing a fully featured MRE, including e.g. a
                 garbage collector and JIT compiler, is a herculean
                 task. As a result, new languages cannot easily take
                 advantage of the benefits of MREs, and it is difficult
                 to experiment with extensions of existing MRE based
                 languages.\par

                 This paper describes and evaluates VMKit, a first
                 attempt to build a common substrate that eases the
                 development of high-level MREs. We have successfully
                 used VMKit to build two MREs: a Java Virtual Machine
                 and a Common Language Runtime. We provide an extensive
                 study of the lessons learned in developing this
                 infrastructure, and assess the ease of implementing new
                 MREs or MRE extensions and the resulting performance.
                 In particular, it took one of the authors only one
                 month to develop a Common Language Runtime using VMKit.
                 VMKit furthermore has performance comparable to the
                 well-established open-source MREs Cacao, Apache Harmony
                 and Mono, and is 1.2 to 3 times slower than JikesRVM on
                 most of the Dacapo benchmarks.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  keywords =     "just in time compiler; virtual machine; vmkit",
}

@Article{Gill:2010:MDP,
  author =       "Nasib Singh Gill and Pradeep Tomar",
  title =        "Modified development process of component-based
                 software engineering",
  journal =      j-SIGSOFT,
  volume =       "35",
  number =       "2",
  pages =        "1--6",
  month =        mar,
  year =         "2010",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/1734103.1734120",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:15:52 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  abstract =     "Component-based software engineering (CBSE) is a
                 branch of software engineering, the priority of which
                 is the separation of concerns in respect of the
                 wide-ranging functionality available throughout a given
                 software system. CBSE emphasizes on building system by
                 reusing high quality configurable software components.
                 This reduces its development cost as well as
                 time-to-market and ensures higher reliability, better
                 maintainability and quality by exploiting reusability.
                 In the traditional approach, when a software system is
                 going to be developed, the implementation has to be
                 done from scratch. With the advent of Object-Oriented
                 Technology (OOT), reusable software components have
                 become an indispensable part of programming knowledge.
                 In addition to those classes and methods included in
                 standard libraries of programming languages, such as
                 the Java API library, many reusable software components
                 are developed by software development organizations
                 specifically for reuse or repackaged from previously
                 developed systems. We propose here a modified
                 development process of CBSE and present our modified
                 development process of CBSE for increasing reusability
                 in different abstraction levels: architecture level,
                 modular design level and framework level. This modified
                 development process of CBSE change the reusability
                 approach into two different approaches
                 composition-based approach and generation-based. Lastly
                 on the basis of these two approaches we divide
                 component reuse into two different processes. First one
                 is process of development of reusable components which
                 is composition-based approach and second one is process
                 of development with reusable components which is based
                 on the generation-based according X model with the
                 benefits of reusable components in programming",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Book{Goodrich:2010:DSA,
  author =       "Michael T. Goodrich and Roberto Tamassia",
  title =        "Data Structures and Algorithms in {Java}",
  publisher =    pub-WILEY,
  address =      pub-WILEY:adr,
  edition =      "Fifth",
  pages =        "xxii + 714",
  year =         "2010",
  ISBN =         "0-470-38326-7 (hardcover), 0-470-39880-9 (paperback)",
  ISBN-13 =      "978-0-470-38326-1 (hardcover), 978-0-470-39880-7
                 (paperback)",
  LCCN =         "QA76.73.J38 G66 2010",
  bibdate =      "Thu Mar 22 12:04:32 MDT 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigact.bib;
                 z3950.loc.gov:7090/Voyager",
  acknowledgement = ack-nhfb,
  subject =      "Java (Computer program language); Data structures
                 (Computer science); Computer algorithms",
}

@Article{Haubl:2010:CES,
  author =       "Christian H{\"a}ubl and Christian Wimmer and Hanspeter
                 M{\"o}ssenb{\"o}ck",
  title =        "Compact and efficient strings for {Java}",
  journal =      j-SCI-COMPUT-PROGRAM,
  volume =       "75",
  number =       "11",
  pages =        "1077--1094",
  day =          "1",
  month =        nov,
  year =         "2010",
  CODEN =        "SCPGD4",
  ISSN =         "0167-6423 (print), 1872-7964 (electronic)",
  ISSN-L =       "0167-6423",
  bibdate =      "Fri Apr 1 18:39:38 MDT 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://www.sciencedirect.com/science/journal/01676423",
  acknowledgement = ack-nhfb,
  fjournal =     "Science of Computer Programming",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01676423",
}

@Article{Heidenreich:2010:GST,
  author =       "Florian Heidenreich and Jendrik Johannes and Mirko
                 Seifert and Christian Wende and Marcel B{\"o}hme",
  title =        "Generating safe template languages",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "2",
  pages =        "99--108",
  month =        feb,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1621607.1621624",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Aug 31 22:37:56 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "Template languages are widely used within generative
                 programming, because they provide intuitive means to
                 generate software artefacts expressed in a specific
                 object language. However, most template languages
                 perform template instantiation on the level of string
                 literals, which allows neither syntax checks nor
                 semantics analysis. To make sure that generated
                 artefacts always conform to the object language, we
                 propose to perform static analysis at template design
                 time. In addition, the increasing popularity of
                 domainspecific languages (DSLs) demands an approach
                 that allows to reuse both the concepts of template
                 languages and the corresponding tools.\par

                 In this paper we address the issues mentioned above by
                 presenting how existing languages can be automatically
                 extended with generic template concepts (e.g.,
                 placeholders, loops, conditions) to obtain safe
                 template languages. These languages provide means for
                 syntax checking and static semantic analysis w.r.t. the
                 object language at template design time. We discuss the
                 prerequisites for this extension, analyse the types of
                 correctness properties that can be assured at template
                 design time, and exemplify the key benefits of this
                 approach on a textual DSL and Java.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  keywords =     "generative programming; language extension; safe
                 authoring; template language",
}

@Article{Hellyer:2010:LCW,
  author =       "Laurence Hellyer and Richard Jones and Antony L.
                 Hosking",
  title =        "The locality of concurrent write barriers",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "8",
  pages =        "83--92",
  month =        aug,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1806651.1806666",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Oct 8 17:55:48 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "Concurrent and incremental collectors require barriers
                 to ensure correct synchronisation between mutator and
                 collector. The overheads imposed by particular barriers
                 on particular systems have been widely studied.
                 Somewhat fewer studies have also compared barriers in
                 terms of their termination properties or the volume of
                 floating garbage they generate. Until now, the
                 consequences for locality of different barrier choices
                 has not been studied, although locality will be of
                 increasing importance for emerging architectures. This
                 paper provides a study of the locality of concurrent
                 write barriers, independent of the processor
                 architecture, virtual machine, compiler or garbage
                 collection algorithm.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  keywords =     "garbage collection; java; language implementation;
                 memory management",
}

@Article{Higuera-Toledano:2010:ISI,
  author =       "M. Teresa Higuera-Toledano and Doug Locke and Angelo
                 Corsaro",
  title =        "Introduction to special issue on {Java} technologies
                 for real-time and embedded systems",
  journal =      j-TECS,
  volume =       "10",
  number =       "1",
  pages =        "1:1--1:??",
  month =        aug,
  year =         "2010",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/1814539.1814540",
  ISSN =         "1539-9087 (print), 1558-3465 (electronic)",
  ISSN-L =       "1539-9087",
  bibdate =      "Mon Aug 30 15:29:45 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  articleno =    "1",
  fjournal =     "ACM Transactions on Embedded Computing Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?&idx=J840",
}

@Article{Hsiao:2010:EST,
  author =       "Chun-Feng Hsiao and Chih-Ping Chu",
  title =        "Enhancing {SCORM} through creating a reusable {Java}
                 class repository",
  journal =      j-SPE,
  volume =       "40",
  number =       "10",
  pages =        "865--881",
  month =        sep,
  year =         "2010",
  CODEN =        "SPEXBL",
  DOI =          "https://doi.org/10.1002/spe.979",
  ISSN =         "0038-0644 (print), 1097-024X (electronic)",
  ISSN-L =       "0038-0644",
  bibdate =      "Tue Jun 21 17:09:49 MDT 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Software---Practice and Experience",
  journal-URL =  "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)1097-024X",
  onlinedate =   "7 May 2010",
}

@Article{James:2010:FMC,
  author =       "Perry R. James and Patrice Chalin",
  title =        "Faster and More Complete Extended Static Checking for
                 the {Java} Modeling Language",
  journal =      j-J-AUTOM-REASON,
  volume =       "44",
  number =       "1--2",
  pages =        "??--??",
  month =        feb,
  year =         "2010",
  CODEN =        "JAREEW",
  DOI =          "https://doi.org/10.1007/s10817-009-9134-9",
  ISSN =         "0168-7433 (print), 1573-0670 (electronic)",
  ISSN-L =       "0168-7433",
  bibdate =      "Sat Apr 2 11:10:16 MDT 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/jautomreason.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://link.springer.com/article/10.1007/s10817-009-9134-9",
  acknowledgement = ack-nhfb,
  ajournal =     "J. Autom. Reason.",
  articleno =    "145",
  fjournal =     "Journal of Automated Reasoning",
  journal-URL =  "http://link.springer.com/journal/10817",
}

@Article{Joseph:2010:PII,
  author =       "Damien Joseph and Soon Ang and Roger H. L. Chang and
                 Sandra A. Slaughter",
  title =        "Practical intelligence in {IT}: assessing soft skills
                 of {IT} professionals",
  journal =      j-CACM,
  volume =       "53",
  number =       "2",
  pages =        "149--154",
  month =        feb,
  year =         "2010",
  CODEN =        "CACMA2",
  DOI =          "https://doi.org/10.1145/1646353.1646391",
  ISSN =         "0001-0782 (print), 1557-7317 (electronic)",
  ISSN-L =       "0001-0782",
  bibdate =      "Thu Feb 4 17:13:32 MST 2010",
  bibsource =    "http://www.acm.org/pubs/contents/journals/cacm/;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "What qualities make a successful it professional?
                 Certainty strong technical skills are sine qua non. As
                 a result, the technology geek remains the stereotype of
                 an information technology (IT) professional. Indeed,
                 when companies hire IT professionals, their focus is
                 often on the 'hard' skills needed to perform the work,
                 such as years of Java programming
                 experience.\par

                 However, there is a growing (and gnawing) awareness
                 that technical skills alone are insufficient for
                 success in IT, particularly in today's dynamic,
                 distributed and complex workplace. Companies are
                 exploring outsourcing and offshoring to become more
                 flexible and contain costs while strategically
                 leveraging IT. Consequently, IT professionals (whether
                 onsite or offshore, in-house or outsourced) must
                 acquire a broader set of skills beyond their
                 traditional technical skills. These broader managerial
                 or interpersonal skills are generically labeled 'soft
                 skills.'\par

                 Despite the increasing importance of soft skills, very
                 little systematic research has conceptualized such
                 skills and even less has measured these skills. Given
                 this gap in the literature, this article introduces
                 'practical intelligence' as the overarching concept
                 that could provide a better understanding of this
                 broader set of skills required of IT professionals. We
                 describe the development of the SoftSkills for IT
                 (SSIT) instrument for assessing an IT professional's
                 level of practical intelligence, and report the results
                 of a study that validates this instrument by comparing
                 the practical intelligence of experienced IT
                 professionals versus novices. We conclude by drawing
                 out implications of our study for IT recruitment,
                 training and development, and suggest future research
                 directions.",
  acknowledgement = ack-nhfb,
  fjournal =     "Communications of the ACM",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J79",
}

@Article{Kienle:2010:ATT,
  author =       "Holger M. Kienle",
  title =        "It's About Time to Take {JavaScript} (More)
                 Seriously",
  journal =      j-IEEE-SOFTWARE,
  volume =       "27",
  number =       "3",
  pages =        "60--62",
  month =        may # "\slash " # jun,
  year =         "2010",
  CODEN =        "IESOEG",
  DOI =          "https://doi.org/10.1109/MS.2010.76",
  ISSN =         "0740-7459 (print), 0740-7459 (electronic)",
  ISSN-L =       "0740-7459",
  bibdate =      "Thu May 13 07:56:44 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE Software",
  journal-URL =  "http://www.computer.org/portal/web/csdl/magazines/software",
}

@Article{Kim:2010:EAE,
  author =       "Minseong Kim and Andy Wellings",
  title =        "Efficient asynchronous event handling in the real-time
                 specification for {Java}",
  journal =      j-TECS,
  volume =       "10",
  number =       "1",
  pages =        "5:1--5:??",
  month =        aug,
  year =         "2010",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/1814539.1814544",
  ISSN =         "1539-9087 (print), 1558-3465 (electronic)",
  ISSN-L =       "1539-9087",
  bibdate =      "Mon Aug 30 15:29:45 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "The Real-Time Specification for Java (RTSJ) is
                 becoming mature. It has been implemented, formed the
                 basis for research and used in serious applications.
                 Some strengths and weaknesses are emerging. One of the
                 areas that requires further elaboration is asynchronous
                 event handling (AEH). The primary goal for handlers in
                 the RTSJ is to have a lightweight concurrency
                 mechanism. Some implementation will, however, simply
                 map a handler to a real-time thread and this results in
                 undermining the original motivations and introduces
                 performance penalties. However it is generally unclear
                 how to map handlers to real-time threads effectively.
                 Also the support for nonblocking handlers in the RTSJ
                 is criticized as lacking in configurability as
                 implementations are unable to take advantage of them.
                 This article, therefore, examines the AEH techniques
                 used in some popular RTSJ implementations and proposes
                 two efficient AEH models for the RTSJ. We then define
                 formal models of the RTSJ AEH implementations using the
                 automata formalism provided by the UPPAAL model
                 checking tool. Using the automata models, their
                 properties are explored and verified. In the proposed
                 models, blocking and nonblocking handlers are serviced
                 by different algorithms. In this way, it is possible to
                 assign a real-time thread to a handler at the right
                 time in the right place while maintaining the fewest
                 possible threads overall and to give a certain level of
                 configurability to AEH. We also have implemented the
                 proposed models on an existing RTSJ implementation,
                 jRate and executed a set of performance tests that
                 measure their respective dispatch and multiple-handler
                 completion latencies. The results from the tests and
                 the verifications indicate that the proposed models
                 require fewer threads on average with better
                 performance than other approaches.",
  acknowledgement = ack-nhfb,
  articleno =    "5",
  fjournal =     "ACM Transactions on Embedded Computing Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?&idx=J840",
  keywords =     "asynchronous event handling; blocking handler;
                 multiple-server switching phenomenon; nonblocking
                 handler; RTSJ",
}

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

@Article{Kolling:2010:GPE,
  author =       "Michael K{\"o}lling",
  title =        "The {Greenfoot} Programming Environment",
  journal =      j-TOCE,
  volume =       "10",
  number =       "4",
  pages =        "14:1--14:??",
  month =        nov,
  year =         "2010",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/1868358.1868361",
  ISSN =         "1946-6226",
  bibdate =      "Thu Dec 9 11:26:15 MST 2010",
  bibsource =    "http://www.acm.org/pubs/toce;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "Greenfoot is an educational integrated development
                 environment aimed at learning and teaching programming.
                 It is aimed at a target audience of students from about
                 14 years old upwards, and is also suitable for college-
                 and university-level education. Greenfoot combines
                 graphical, interactive output with programming in Java,
                 a standard, text-based object-oriented programming
                 language. This article first describes Greenfoot and
                 then goes on to discuss design goals and motivations,
                 strengths and weaknesses of the system, and its
                 relation to two environments with similar goals,
                 Scratch and Alice.",
  acknowledgement = ack-nhfb,
  articleno =    "14",
  fjournal =     "ACM Transactions on Computing Education",
}

@Article{Lee:2010:JSD,
  author =       "Byeongcheol Lee and Ben Wiedermann and Martin Hirzel
                 and Robert Grimm and Kathryn S. McKinley",
  title =        "{Jinn}: synthesizing dynamic bug detectors for foreign
                 language interfaces",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "6",
  pages =        "36--49",
  month =        jun,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1809028.1806601",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Oct 8 17:53:18 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "Programming language specifications mandate static and
                 dynamic analyses to preclude syntactic and semantic
                 errors. Although individual languages are usually
                 well-specified, composing languages is not, and this
                 poor specification is a source of many errors in {\em
                 multilingual\/} programs. For example, virtually all
                 Java programs compose Java and C using the Java Native
                 Interface (JNI). Since JNI is informally specified,
                 developers have difficulty using it correctly, and
                 current Java compilers and virtual machines (VMs)
                 inconsistently check only a subset of JNI
                 constraints.\par

                 This paper's most significant contribution is to show
                 how to synthesize dynamic analyses from state machines
                 to detect foreign function interface (FFI) violations.
                 We identify three classes of FFI constraints encoded by
                 eleven state machines that capture thousands of JNI and
                 Python/C FFI rules. We use a mapping function to
                 specify which state machines, transitions, and program
                 entities (threads, objects, references) to check at
                 each FFI call and return. From this function, we
                 synthesize a context-specific dynamic analysis to find
                 FFI bugs. We build bug detection tools for JNI and
                 Python/C using this approach. For JNI, we dynamically
                 and transparently interpose the analysis on Java and C
                 language transitions through the JVM tools interface.
                 The resulting tool, called Jinn, is compiler and
                 virtual machine {\em independent}. It detects and
                 diagnoses a wide variety of FFI bugs that other tools
                 miss. This approach greatly reduces the annotation
                 burden by exploiting common FFI constraints: whereas
                 the generated Jinn code is 22,000+ lines, we wrote only
                 1,400 lines of state machine and mapping code. Overall,
                 this paper lays the foundation for a more principled
                 approach to developing correct multilingual software
                 and a more concise and automated approach to FFI
                 specification.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  keywords =     "dynamic analysis; ffi bugs; foreign function
                 interfaces (FFI); java native interface (jni);
                 multilingual programs; python/C; specification;
                 specification generation",
}

@Article{Lerner:2010:FTJ,
  author =       "Reuven M. Lerner",
  title =        "At the forge: testing {JavaScript}",
  journal =      j-LINUX-J,
  volume =       "2010",
  number =       "191",
  pages =        "6:1--6:??",
  month =        mar,
  year =         "2010",
  CODEN =        "LIJOFX",
  ISSN =         "1075-3583 (print), 1938-3827 (electronic)",
  ISSN-L =       "1075-3583",
  bibdate =      "Tue Nov 23 11:41:53 MST 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  articleno =    "6",
  fjournal =     "Linux Journal",
  journal-URL =  "http://portal.acm.org/citation.cfm?id=J508",
}

@Article{Lerner:2010:SDT,
  author =       "Benjamin S. Lerner and Herman Venter and Dan
                 Grossman",
  title =        "Supporting dynamic, third-party code customizations in
                 {JavaScript} using aspects",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "10",
  pages =        "361--376",
  month =        oct,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1932682.1869490",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Wed Jan 26 15:13:46 MST 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Long:2010:TDSa,
  author =       "Brad Long",
  title =        "Towards the design of a set-based {Java} collections
                 framework",
  journal =      j-SIGSOFT,
  volume =       "35",
  number =       "5",
  pages =        "1--7",
  month =        sep,
  year =         "2010",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/1838687.1838705",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:15:57 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  abstract =     "The Java Collections Framework (JCF) was introduced as
                 standard in JDK 1.2. Since then several significant
                 enhancements have been made including the introduction
                 of generics and typed collections. One striking design
                 choice of the Java language designers was the exclusion
                 of map from the collections hierarchy. This paper looks
                 at how maps could be incorporated into the Java
                 collections hierarchy by describing early work on YACL
                 (Yet Another Collections Library). The intention of
                 YACL is to provide a suite of set-based collections
                 classes and operations whilst continuing to be
                 compatible with the JCF.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Long:2010:TDSb,
  author =       "Brad Long",
  title =        "Towards the design of a set-based {Java} collections
                 framework",
  journal =      j-SIGSOFT,
  volume =       "35",
  number =       "6",
  pages =        "1--7",
  month =        nov,
  year =         "2010",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/1874391.1874401",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:15:58 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  abstract =     "The Java Collections Framework (JCF) was introduced as
                 standard in JDK 1.2. Since then several significant
                 enhancements have been made including the introduction
                 of generics and typed collections. One striking design
                 choice of the Java language designers was the exclusion
                 of map from the collections hierarchy. This paper looks
                 at how maps could be incorporated into the Java
                 collections hierarchy by describing early work on YACL
                 (Yet Another Collections Library). The intention of
                 YACL is to provide a suite of set-based collections
                 classes and operations whilst continuing to be
                 compatible with the JCF",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Marino:2010:DSE,
  author =       "Daniel Marino and Abhayendra Singh and Todd Millstein
                 and Madanlal Musuvathi and Satish Narayanasamy",
  title =        "{DRFX}: a simple and efficient memory model for
                 concurrent programming languages",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "6",
  pages =        "351--362",
  month =        jun,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1806596.1806636",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Oct 8 17:53:18 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "The most intuitive memory model for shared-memory
                 multithreaded programming is {\em sequential
                 consistency\/} (SC), but it disallows the use of many
                 compiler and hardware optimizations thereby impacting
                 performance. Data-race-free (DRF) models, such as the
                 proposed C++0x memory model, guarantee SC execution for
                 datarace-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.\par

                 We present the DRFx memory model, which is simple for
                 programmers to understand and use while still
                 supporting many common optimizations. We introduce a
                 {\em memory model (MM) exception\/} which can be
                 signaled to halt execution. If a program executes
                 without throwing this exception, then DRFx guarantees
                 that the execution is SC. If a program throws an MM
                 exception during an execution, then DRFx 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 about this model, describe a
                 compiler and hardware design suitable for DRFx, and
                 evaluate the performance overhead due to our compiler
                 and hardware requirements.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  keywords =     "data races; memory model exception; memory models;
                 sequential consistency; soft fences",
}

@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/java2010.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,
  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{Mateos:2010:ANI,
  author =       "Cristian Mateos and Alejandro Zunino and Marcelo
                 Campo",
  title =        "An approach for non-intrusively adding malleable
                 fork\slash join parallelism into ordinary {JavaBean}
                 compliant applications",
  journal =      j-COMP-LANGS-SYS-STRUCT,
  volume =       "36",
  number =       "3",
  pages =        "288--315",
  month =        oct,
  year =         "2010",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1016/j.cl.2009.12.003",
  ISSN =         "1477-8424 (print), 1873-6866 (electronic)",
  ISSN-L =       "1477-8424",
  bibdate =      "Thu Mar 8 08:39:20 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/complngs.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://www.sciencedirect.com/science/journal/14778424",
  URL =          "http://www.sciencedirect.com/science/article/pii/S1477842410000035",
  acknowledgement = ack-nhfb,
  fjournal =     "Computer Languages, Systems \& Structures",
  journal-URL =  "http://www.sciencedirect.com/science/journal/14778424",
}

@Article{Mateos:2010:MJN,
  author =       "Cristian Mateos and Alejandro Zunino and Marcelo
                 Campo",
  title =        "{m-JGRIM}: a novel middleware for {Gridifying Java}
                 applications into mobile {Grid} services",
  journal =      j-SPE,
  volume =       "40",
  number =       "4",
  pages =        "331--362",
  day =          "10",
  month =        apr,
  year =         "2010",
  CODEN =        "SPEXBL",
  DOI =          "https://doi.org/10.1002/spe.961",
  ISSN =         "0038-0644 (print), 1097-024X (electronic)",
  ISSN-L =       "0038-0644",
  bibdate =      "Wed Mar 17 10:16:22 MDT 2010",
  bibsource =    "http://www.interscience.wiley.com/jpages/0038-0644;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://www3.interscience.wiley.com/journalfinder.html",
  acknowledgement = ack-nhfb,
  fjournal =     "Software---Practice and Experience",
  journal-URL =  "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)1097-024X",
  onlinedate =   "Feb 3 2010 10:58AM",
}

@Article{McGachey:2010:CJC,
  author =       "Phil McGachey and Antony L. Hosking and J. Eliot B.
                 Moss",
  title =        "Classifying {Java} class transformations for pervasive
                 virtualized access",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "2",
  pages =        "75--84",
  month =        feb,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1621607.1621620",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Aug 31 22:37:56 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "The indirection of object accesses is a common theme
                 for target domains as diverse as transparent
                 distribution, persistence, and program instrumentation.
                 Virtualizing accesses to fields and methods (by
                 redirecting calls through accessor and indirection
                 methods) allows interposition of arbitrary code,
                 extending the functionality of an application beyond
                 that intended by the original developer.\par

                 We present class modifications performed by our RuggedJ
                 transparent distribution platform for standard Java
                 virtual machines. RuggedJ abstracts over the location
                 of objects by implementing a single object model for
                 local and remote objects. However the implementation of
                 this model is complicated by the presence of native and
                 system code; classes loaded by Java's bootstrap class
                 loader can be rewritten only in a limited manner, and
                 so cannot be modified to conform to RuggedJ's complex
                 object model. We observe that system code comprises the
                 majority of a given Java application: an average of
                 76\% in the applications we study. We consider the
                 constraints imposed upon pervasive class transformation
                 within Java, and present a framework for systematically
                 rewriting arbitrary applications. Our system
                 accommodates all system classes, allowing both user and
                 system classes alike to be referenced using a single
                 object model.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  keywords =     "Java; object model; program transformation",
}

@Article{McIlroy:2010:HJR,
  author =       "Ross McIlroy and Joe Sventek",
  title =        "{Hera-JVM}: a runtime system for heterogeneous
                 multi-core architectures",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "10",
  pages =        "205--222",
  month =        oct,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1932682.1869478",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Wed Jan 26 15:13:46 MST 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{McLane:2010:UIV,
  author =       "Jonathan C. McLane and W. Walter Czech and David A.
                 Yuen and Mike R. Knox and Shuo Wang and Jim B. S.
                 Greensky and Erik O. D. Sevre",
  title =        "Ubiquitous interactive visualization of large-scale
                 simulations in geosciences over a {Java}-based
                 web-portal",
  journal =      j-CCPE,
  volume =       "22",
  number =       "12",
  pages =        "1750--1773",
  day =          "25",
  month =        aug,
  year =         "2010",
  CODEN =        "CCPEBO",
  DOI =          "https://doi.org/10.1002/cpe.1532",
  ISSN =         "1532-0626 (print), 1532-0634 (electronic)",
  ISSN-L =       "1532-0626",
  bibdate =      "Mon Dec 5 10:08:46 MST 2011",
  bibsource =    "http://www.interscience.wiley.com/jpages/1532-0626;
                 https://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Concurrency and Computation: Practice and Experience",
  journal-URL =  "http://www.interscience.wiley.com/jpages/1532-0626",
  onlinedate =   "26 Oct 2009",
}

@Article{Mitchell:2010:FTL,
  author =       "Nick Mitchell and Edith Schonberg and Gary Sevitsky",
  title =        "Four Trends Leading to {Java} Runtime Bloat",
  journal =      j-IEEE-SOFTWARE,
  volume =       "27",
  number =       "1",
  pages =        "56--63",
  month =        jan # "\slash " # feb,
  year =         "2010",
  CODEN =        "IESOEG",
  DOI =          "https://doi.org/10.1109/MS.2010.7",
  ISSN =         "0740-7459 (print), 0740-7459 (electronic)",
  ISSN-L =       "0740-7459",
  bibdate =      "Thu May 13 07:56:44 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE Software",
  journal-URL =  "http://www.computer.org/portal/web/csdl/magazines/software",
}

@Article{Mytkowicz:2010:EAJ,
  author =       "Todd Mytkowicz and Amer Diwan and Matthias Hauswirth
                 and Peter F. Sweeney",
  title =        "Evaluating the accuracy of {Java} profilers",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "6",
  pages =        "187--197",
  month =        jun,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1806596.1806618",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Oct 8 17:53:18 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "Performance analysts profile their programs to find
                 methods that are worth optimizing: the 'hot' methods.
                 This paper shows that four commonly-used Java profilers
                 ({\em xprof , hprof , jprofile, and yourkit\/}) often
                 disagree on the identity of the hot methods. If two
                 profilers disagree, at least one must be incorrect.
                 Thus, there is a good chance that a profiler will
                 mislead a performance analyst into wasting time
                 optimizing a cold method with little or no performance
                 improvement.\par

                 This paper uses causality analysis to evaluate
                 profilers and to gain insight into the source of their
                 incorrectness. It shows that these profilers all
                 violate a fundamental requirement for sampling based
                 profilers: to be correct, a sampling-based profiler
                 must collect samples randomly.\par

                 We show that a proof-of-concept profiler, which
                 collects samples randomly, does not suffer from the
                 above problems. Specifically, we show, using a number
                 of case studies, that our profiler correctly identifies
                 methods that are important to optimize; in some cases
                 other profilers report that these methods are cold and
                 thus not worth optimizing.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  keywords =     "bias; observer effect; profiling",
}

@Article{Nakaike:2010:LER,
  author =       "Takuya Nakaike and Maged M. Michael",
  title =        "Lock elision for read-only critical sections in
                 {Java}",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "6",
  pages =        "269--278",
  month =        jun,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1806596.1806627",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Oct 8 17:53:18 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "It is not uncommon in parallel workloads to encounter
                 shared data structures with read-mostly access
                 patterns, where operations that update data are
                 infrequent and most operations are read-only.
                 Typically, data consistency is guaranteed using mutual
                 exclusion or read-write locks. The cost of atomic
                 update of lock variables result in high overheads and
                 high cache coherence traffic under active sharing, thus
                 slowing down single thread performance and limiting
                 scalability.\par

                 In this paper, we present {\em SOLERO (Software
                 Optimistic Lock Elision for Read-Only critical
                 sections)}, a new lock implementation called for
                 optimizing read-only critical sections in Java based on
                 sequential locks. SOLERO is compatible with the
                 conventional lock implementation of Java. However,
                 unlike the conventional implementation, only critical
                 sections that may write data or have side effects need
                 to update lock variables, while read-only critical
                 sections need only read lock variables without writing
                 them. Each writing critical section changes the lock
                 value to a new value. Hence, a read-only critical
                 section is guaranteed to be consistent if the lock is
                 free and its value does not change from the beginning
                 to the end of the read-only critical section.\par

                 Using Java workloads including SPECjbb2005 and the
                 HashMap and TreeMap Java classes, we evaluate the
                 performance impact of applying SOLERO to read-mostly
                 locks. Our experimental results show performance
                 improvements across the board, often substantial, in
                 both single thread speed and scalability over the
                 conventional lock implementation (mutual exclusion) and
                 read-write locks. SOLERO improves the performance of
                 SPECjbb2005 by 3-5\% on single and multiple threads.
                 The results using the HashMap and TreeMap benchmarks
                 show that SOLERO outperforms the conventional lock
                 implementation and read-write locks by substantial
                 multiples on multi-threads.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  keywords =     "java; just-in-time compiler; lock; lock elision;
                 monitor; optimization; synchronization",
}

@Article{Namjoshi:2010:NOP,
  author =       "Manjiri A. Namjoshi and Prasad A. Kulkarni",
  title =        "Novel online profiling for virtual machines",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "7",
  pages =        "133--144",
  month =        jul,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1735997.1736016",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Oct 8 17:55:01 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "Application {\em profiling\/} is a popular technique
                 to improve program performance based on its behavior.
                 {\em Offline\/} profiling, although beneficial for
                 several applications, fails in cases where prior
                 program runs may not be feasible, or if changes in
                 input cause the profile to not match the behavior of
                 the actual program run. Managed languages, like Java
                 and C\\#, provide a unique opportunity to overcome the
                 drawbacks of offline profiling by generating the
                 profile information online during the current program
                 run. Indeed, online profiling is extensively used in
                 current VMs, especially during selective compilation to
                 improve program {\em startup\/} performance, as well as
                 during other feedback-directed optimizations.\par

                 In this paper we illustrate the drawbacks of the
                 current {\em reactive\/} mechanism of online profiling
                 during selective compilation. Current VM profiling
                 mechanisms are slow -- thereby delaying associated
                 transformations, and estimate future behavior based on
                 the program's immediate past -- leading to potential
                 misspeculation that limit the benefits of compilation.
                 We show that these drawbacks produce an average
                 performance loss of over 14.5\% on our set of benchmark
                 programs, over an {\em ideal offline\/} approach that
                 accurately compiles the hot methods early. We then
                 propose and evaluate the potential of a novel strategy
                 to achieve similar performance benefits with an online
                 profiling approach. Our new online profiling strategy
                 uses early determination of loop iteration bounds to
                 predict future method hotness. We explore and present
                 promising results on the potential, feasibility, and
                 other issues involved for the successful implementation
                 of this approach.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  keywords =     "java; online profiling; virtual machines",
}

@Article{Nasseri:2010:CMR,
  author =       "E. Nasseri and S. Counsell and M. Shepperd",
  title =        "Class movement and re-location: an empirical study of
                 {Java} inheritance evolution",
  journal =      j-J-SYST-SOFTW,
  volume =       "83",
  number =       "2",
  pages =        "303--315",
  month =        feb,
  year =         "2010",
  CODEN =        "JSSODM",
  ISSN =         "0164-1212 (print), 1873-1228 (electronic)",
  ISSN-L =       "0164-1212",
  bibdate =      "Tue Sep 7 07:27:05 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://www.sciencedirect.com/science/journal/01641212",
  acknowledgement = ack-nhfb,
  fjournal =     "The Journal of systems and software",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01641212",
}

@Misc{Nourie:2010:REJ,
  author =       "D. Nourie and M. McCloskey",
  title =        "Regular Expressions and the {Java} Programming
                 Language",
  howpublished = "Web report",
  year =         "2010",
  bibdate =      "Wed Sep 09 10:06:46 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/string-matching.bib",
  URL =          "http://java.sun.com/developer/technicalArticles/releases/1.4regex",
  acknowledgement = ack-nhfb,
}

@Article{Odaira:2010:ERT,
  author =       "Rei Odaira and Kazunori Ogata and Kiyokuni Kawachiya
                 and Tamiya Onodera and Toshio Nakatani",
  title =        "Efficient runtime tracking of allocation sites in
                 {Java}",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "7",
  pages =        "109--120",
  month =        jul,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1837854.1736014",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Oct 8 17:55:01 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "Tracking the allocation site of every object at
                 runtime is useful for reliable, optimized Java. To be
                 used in production environments, the tracking must be
                 accurate with minimal speed loss. Previous approaches
                 suffer from performance degradation due to the
                 additional field added to each object or track the
                 allocation sites only probabilistically. We propose two
                 novel approaches to track the allocation sites of every
                 object in Java with only a 1.0\% slow-down on average.
                 Our first approach, the {\em
                 Allocation-Site-as-a-Hash-code (ASH) Tracker}, encodes
                 the allocation site ID of an object into the hash code
                 field of its header by regarding the ID as part of the
                 hash code. ASH Tracker avoids an excessive increase in
                 hash code collisions by dynamically shrinking the
                 bit-length of the ID as more and more objects are
                 allocated at that site. For those Java VMs without the
                 hash code field, our second approach, the {\em
                 Allocation-Site-via-a-Class-pointer (ASC) Tracker},
                 makes the class pointer field in an object header refer
                 to the allocation site structure of the object, which
                 in turn points to the actual class structure. ASC
                 Tracker mitigates the indirection overhead by
                 constant-class-field duplication and allocation-site
                 equality checks. While a previous approach of adding a
                 4-byte field caused up to 14.4\% and an average 5\%
                 slowdown, both ASH and ASC Trackers incur at most a
                 2.0\% and an average 1.0\% loss. We demonstrate the
                 usefulness of our low-overhead trackers by an
                 allocation-site-aware memory leak detector and
                 allocation-site-based pretenuring in generational GC.
                 Our pretenuring achieved on average 1.8\% and up to
                 11.8\% speedups in SPECjvm2008.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  keywords =     "allocation site; hash code; memory allocation",
}

@Article{Ogata:2010:SJN,
  author =       "Kazunori Ogata and Dai Mikurube and Kiyokuni Kawachiya
                 and Scott Trent and Tamiya Onodera",
  title =        "A study of {Java}'s non-{Java} memory",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "10",
  pages =        "191--204",
  month =        oct,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1932682.1869477",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Wed Jan 26 15:13:46 MST 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Pironti:2010:PCJ,
  author =       "Alfredo Pironti and Riccardo Sisto",
  title =        "Provably correct {Java} implementations of {Spi
                 Calculus} security protocols specifications",
  journal =      j-COMPUT-SECUR,
  volume =       "29",
  number =       "3",
  pages =        "302--314",
  month =        may,
  year =         "2010",
  CODEN =        "CPSEDU",
  ISSN =         "0167-4048 (print), 1872-6208 (electronic)",
  ISSN-L =       "0167-4048",
  bibdate =      "Mon Sep 23 09:46:20 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/computsecur2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "https://www.sciencedirect.com/science/article/pii/S0167404809000832",
  acknowledgement = ack-nhfb,
  fjournal =     "Computers \& Security",
  journal-URL =  "https://www.sciencedirect.com/science/journal/01674048",
}

@Article{Pitter:2010:RTJ,
  author =       "Christof Pitter and Martin Schoeberl",
  title =        "A real-time {Java} chip-multiprocessor",
  journal =      j-TECS,
  volume =       "10",
  number =       "1",
  pages =        "9:1--9:??",
  month =        aug,
  year =         "2010",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/1814539.1814548",
  ISSN =         "1539-9087 (print), 1558-3465 (electronic)",
  ISSN-L =       "1539-9087",
  bibdate =      "Mon Aug 30 15:29:45 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "Chip-multiprocessors are an emerging trend for
                 embedded systems. In this article, we introduce a
                 real-time Java multiprocessor called JopCMP. It is a
                 symmetric shared-memory multiprocessor, and consists of
                 up to eight Java Optimized Processor (JOP) cores, an
                 arbitration control device, and a shared memory. All
                 components are interconnected via a system on chip bus.
                 The arbiter synchronizes the access of multiple CPUs to
                 the shared main memory. In this article, three
                 different arbitration policies are presented,
                 evaluated, and compared with respect to their real-time
                 and average-case performance: a fixed priority, a
                 fair-based, and a time-sliced arbiter.\par

                 Tasks running on different CPUs of a
                 chip-multiprocessor (CMP) influence each others'
                 execution times when accessing a shared memory.
                 Therefore, the system needs an arbiter that is able to
                 limit the worst-case execution time of a task running
                 on a CPU, even though tasks executing simultaneously on
                 other CPUs access the main memory. Our research shows
                 that timing analysis is in fact possible for
                 homogeneous multiprocessor systems with a shared
                 memory. The timing analysis of tasks, executing on the
                 CMP using time-sliced memory arbitration, leads to
                 viable worst-case execution time bounds.\par

                 The time-sliced arbiter divides the memory access time
                 into equal time slots, one time slot for each CPU. This
                 memory arbitration scheme allows for a calculation of
                 upper bounds of Java application worst-case execution
                 times, depending on the number of CPUs, the time slot
                 size, and the memory access time. Examples of
                 worst-case execution time calculation are presented,
                 and the analyzed results of a real-world application
                 task are compared to measured execution time results.
                 Finally, we evaluate the tradeoffs when using a
                 time-predictable solution compared to using
                 average-case optimized chip-multiprocessors, applying
                 three different benchmarks. These experiments are
                 carried out by executing the programs on the CMP
                 prototype.",
  acknowledgement = ack-nhfb,
  articleno =    "9",
  fjournal =     "ACM Transactions on Embedded Computing Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?&idx=J840",
  keywords =     "Java processor; multiprocessor; Real-time system;
                 shared memory; worst-case execution time",
}

@Article{Pizlo:2010:SFT,
  author =       "Filip Pizlo and Lukasz Ziarek and Petr Maj and Antony
                 L. Hosking and Ethan Blanton and Jan Vitek",
  title =        "{SCHISM}: fragmentation-tolerant real-time garbage
                 collection",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "6",
  pages =        "146--159",
  month =        jun,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1806596.1806615",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Oct 8 17:53:18 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "Managed languages such as Java and C\# are being
                 considered for use in hard real-time systems. A hurdle
                 to their widespread adoption is the lack of garbage
                 collection algorithms that offer predictable
                 space-and-time performance in the face of
                 fragmentation. We introduce SCHISM/CMR, a new
                 concurrent and real-time garbage collector that is
                 fragmentation tolerant and guarantees time-and-space
                 worst-case bounds while providing good throughput.
                 SCHISM/CMR combines mark-region collection of
                 fragmented objects and arrays (arraylets) with separate
                 replication-copying collection of immutable arraylet
                 spines, so as to cope with external fragmentation when
                 running in small heaps. We present an implementation of
                 SCHISM/CMR in the Fiji VM, a high-performance Java
                 virtual machine for mission-critical systems, along
                 with a thorough experimental evaluation on a wide
                 variety of architectures, including server-class and
                 embedded systems. The results show that SCHISM/CMR
                 tolerates fragmentation better than previous schemes,
                 with a much more acceptable throughput penalty.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  keywords =     "fragmentation; mark-region; mark-sweep; real-time;
                 replication-copying",
}

@Article{Richards:2010:ADB,
  author =       "Gregor Richards and Sylvain Lebresne and Brian Burg
                 and Jan Vitek",
  title =        "An analysis of the dynamic behavior of {JavaScript}
                 programs",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "6",
  pages =        "1--12",
  month =        jun,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1806596.1806598",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Oct 8 17:53:18 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "The JavaScript programming language is widely used for
                 web programming and, increasingly, for general purpose
                 computing. As such, improving the correctness, security
                 and performance of JavaScript applications has been the
                 driving force for research in type systems, static
                 analysis and compiler techniques for this language.
                 Many of these techniques aim to reign in some of the
                 most dynamic features of the language, yet little seems
                 to be known about how programmers actually utilize the
                 language or these features. In this paper we perform an
                 empirical study of the dynamic behavior of a corpus of
                 widely-used JavaScript programs, and analyze how and
                 why the dynamic features are used. We report on the
                 degree of dynamism that is exhibited by these
                 JavaScript programs and compare that with assumptions
                 commonly made in the literature and accepted industry
                 benchmark suites.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  keywords =     "dynamic behavior; dynamic metrics; execution tracing;
                 javascript; program analysis",
}

@Article{Sartor:2010:ZRD,
  author =       "Jennifer B. Sartor and Stephen M. Blackburn and Daniel
                 Frampton and Martin Hirzel and Kathryn S. McKinley",
  title =        "{Z}-rays: divide arrays and conquer speed and
                 flexibility",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "6",
  pages =        "471--482",
  month =        jun,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1806596.1806649",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Oct 8 17:53:18 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "Arrays are the ubiquitous organization for indexed
                 data. Throughout programming language evolution,
                 implementations have laid out arrays contiguously in
                 memory. This layout is problematic in space and time.
                 It causes heap fragmentation, garbage collection pauses
                 in proportion to array size, and wasted memory for
                 sparse and over-provisioned arrays. Because of array
                 virtualization in managed languages, an array layout
                 that consists of indirection pointers to fixed-size
                 discontiguous memory blocks can mitigate these problems
                 transparently. This design however incurs significant
                 overhead, but is justified when real-time deadlines and
                 space constraints trump performance.\par

                 This paper proposes {\em z-rays}, a discontiguous array
                 design with flexibility and efficiency. A z-ray has a
                 spine with indirection pointers to fixed-size memory
                 blocks called {\em arraylets}, and uses five
                 optimizations: (1) inlining the first N array bytes
                 into the spine, (2) lazy allocation, (3) zero
                 compression, (4) fast array copy, and (5) arraylet
                 copy-on-write. Whereas discontiguous arrays in prior
                 work improve responsiveness and space efficiency,
                 z-rays combine time efficiency and flexibility. On
                 average, the best z-ray configuration performs within
                 12.7\% of an unmodified Java Virtual Machine on 19
                 benchmarks, whereas previous designs have {\em two to
                 three times\/} higher overheads. Furthermore, language
                 implementers can configure z-ray optimizations for
                 various design goals. This combination of performance
                 and flexibility creates a better building block for
                 past and future array optimization.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  keywords =     "arraylets; arrays; compression; heap; z-rays",
}

@Article{Schmidt:2010:ERA,
  author =       "Richard B. Schmidt",
  title =        "Experience report: {Ada} \& {Java} integration in the
                 {FAA}'s {ERAM SWIM} program",
  journal =      j-SIGADA-LETTERS,
  volume =       "30",
  number =       "3",
  pages =        "33--34",
  month =        dec,
  year =         "2010",
  CODEN =        "AALEE5",
  DOI =          "https://doi.org/10.1145/1879097.1879075",
  ISSN =         "1094-3641 (print), 1557-9476 (electronic)",
  ISSN-L =       "1094-3641",
  bibdate =      "Mon Jan 10 13:57:43 MST 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGAda Ada Letters",
}

@Article{Schoeberl:2010:NRT,
  author =       "Martin Schoeberl and Wolfgang Puffitsch",
  title =        "Nonblocking real-time garbage collection",
  journal =      j-TECS,
  volume =       "10",
  number =       "1",
  pages =        "6:1--6:??",
  month =        aug,
  year =         "2010",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/1814539.1814545",
  ISSN =         "1539-9087 (print), 1558-3465 (electronic)",
  ISSN-L =       "1539-9087",
  bibdate =      "Mon Aug 30 15:29:45 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "A real-time garbage collector has to fulfill two basic
                 properties: ensure that programs with bounded
                 allocation rates do not run out of memory and provide
                 short blocking times. Even for incremental garbage
                 collectors, two major sources of blocking exist,
                 namely, root scanning and heap compaction. Finding root
                 nodes of an object graph is an integral part of tracing
                 garbage collectors and cannot be circumvented. Heap
                 compaction is necessary to avoid probably unbounded
                 heap fragmentation, which in turn would lead to
                 unacceptably high memory consumption. In this article,
                 we propose solutions to both issues.\par

                 Thread stacks are local to a thread, and root scanning,
                 therefore, only needs to be atomic with respect to the
                 thread whose stack is scanned. This fact can be
                 utilized by either blocking only the thread whose stack
                 is scanned, or by delegating the responsibility for
                 root scanning to the application threads. The latter
                 solution eliminates blocking due to root scanning
                 completely. The impact of this solution on the
                 execution time of a garbage collector is shown for two
                 different variants of such a root scanning
                 algorithm.\par

                 During heap compaction, objects are copied. Copying is
                 usually performed atomically to avoid interference with
                 application threads, which could render the state of an
                 object inconsistent. Copying of large objects and
                 especially large arrays introduces long blocking times
                 that are unacceptable for real-time systems. In this
                 article, an interruptible copy unit is presented that
                 implements nonblocking object copy. The unit can be
                 interrupted after a single word move.\par

                 We evaluate a real-time garbage collector that uses the
                 proposed techniques on a Java processor. With this
                 garbage collector, it is possible to run high-priority
                 hard real-time tasks at 10 kHz parallel to the garbage
                 collection task on a 100 MHz system.",
  acknowledgement = ack-nhfb,
  articleno =    "6",
  fjournal =     "ACM Transactions on Embedded Computing Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?&idx=J840",
  keywords =     "Garbage collection; nonblocking copying; real-time;
                 root scanning",
}

@Article{Schoeberl:2010:WCE,
  author =       "Martin Schoeberl and Wolfgang Puffitsch and Rasmus
                 Ulslev Pedersen and Benedikt Huber",
  title =        "Worst-case execution time analysis for a {Java}
                 processor",
  journal =      j-SPE,
  volume =       "40",
  number =       "6",
  pages =        "507--542",
  month =        may,
  year =         "2010",
  CODEN =        "SPEXBL",
  DOI =          "https://doi.org/10.1002/spe.968",
  ISSN =         "0038-0644 (print), 1097-024X (electronic)",
  ISSN-L =       "0038-0644",
  bibdate =      "Tue Jun 21 17:09:46 MDT 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Software---Practice and Experience",
  journal-URL =  "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)1097-024X",
  onlinedate =   "6 Apr 2010",
}

@Article{Schultz:2010:WAJ,
  author =       "Christopher Schultz",
  title =        "{Web} applications with {Java\slash JSP}",
  journal =      j-LINUX-J,
  volume =       "2010",
  number =       "197",
  pages =        "4:1--4:??",
  month =        sep,
  year =         "2010",
  CODEN =        "LIJOFX",
  ISSN =         "1075-3583 (print), 1938-3827 (electronic)",
  ISSN-L =       "1075-3583",
  bibdate =      "Tue Nov 23 11:41:55 MST 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  articleno =    "4",
  fjournal =     "Linux Journal",
  journal-URL =  "http://portal.acm.org/citation.cfm?id=J508",
}

@Article{Sciampacone:2010:EMS,
  author =       "R. A. Sciampacone and V. Sundaresan and D. Maier and
                 T. Gray-Donald",
  title =        "Exploitation of multicore systems in a {Java} virtual
                 machine",
  journal =      j-IBM-JRD,
  volume =       "54",
  number =       "5",
  pages =        "1:1--1:11",
  month =        "????",
  year =         "2010",
  CODEN =        "IBMJAE",
  DOI =          "https://doi.org/10.1147/JRD.2010.2057911",
  ISSN =         "0018-8646 (print), 2151-8556 (electronic)",
  ISSN-L =       "0018-8646",
  bibdate =      "Sun Feb 20 14:29:19 MST 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://www.research.ibm.com/journal/",
  acknowledgement = ack-nhfb,
  fjournal =     "IBM Journal of Research and Development",
  journal-URL =  "http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=5288520",
}

@Article{Servetto:2010:MMC,
  author =       "Marco Servetto and Elena Zucca",
  title =        "{MetaFJig}: a meta-circular composition language for
                 {Java}-like classes",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "10",
  pages =        "464--483",
  month =        oct,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1932682.1869498",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Wed Jan 26 15:13:46 MST 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Siebert:2010:CPR,
  author =       "Fridtjof Siebert",
  title =        "Concurrent, parallel, real-time garbage-collection",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "8",
  pages =        "11--20",
  month =        aug,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1837855.1806654",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Oct 8 17:55:48 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "With the current developments in CPU implementations,
                 it becomes obvious that ever more parallel multicore
                 systems will be used even in embedded controllers that
                 require real-time guarantees. When garbage collection
                 is used in these systems, parallel and concurrent
                 garbage collection brings important performance
                 advantages in the average case. In a real-time system,
                 however, guarantees on the GC's performance in the
                 worst case are required.\par

                 This paper explains how the single-CPU real-time GC of
                 the Java implementation JamaicaVM was changed to make
                 it a hard real-time garbage collector that is parallel
                 and concurrent. Parallel means that an arbitrary number
                 of CPUs may perform GC work in parallel, while
                 concurrent means that the GC work can be performed
                 concurrently to the application code without
                 pre-empting the application. In addition, the single
                 units of work that this garbage collector has to
                 perform are very small and uniform and the total amount
                 of GC work is bounded by a function of the heap size,
                 such that it becomes possible for any application that
                 has a bounded amount of reachable memory to run the GC
                 work such that sufficient GC progress can be ensured
                 for the application never to run out of heap space.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  keywords =     "concurrent; garbage collection; java; multicore;
                 parallel; real-time",
}

@Article{Singer:2010:EGC,
  author =       "Jeremy Singer and Richard E. Jones and Gavin Brown and
                 Mikel Luj{\'a}n",
  title =        "The economics of garbage collection",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "8",
  pages =        "103--112",
  month =        aug,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1806651.1806669",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Oct 8 17:55:48 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "This paper argues that economic theory can improve our
                 understanding of memory management. We introduce the
                 {\em allocation curve}, as an analogue of the demand
                 curve from microeconomics. An allocation curve for a
                 program characterises how the amount of garbage
                 collection activity required during its execution
                 varies in relation to the heap size associated with
                 that program. The standard treatment of microeconomic
                 demand curves (shifts and elasticity) can be applied
                 directly and intuitively to our new allocation curves.
                 As an application of this new theory, we show how {\em
                 allocation elasticity\/} can be used to control the
                 heap growth rate for variable sized heaps in Jikes
                 RVM.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  keywords =     "allocation curve; elasticity; garbage collection;
                 java; memory management; microeconomics",
}

@Article{Smans:2010:AVJ,
  author =       "Jan Smans and Bart Jacobs and Frank Piessens and
                 Wolfram Schulte",
  title =        "Automatic verification of {Java} programs with dynamic
                 frames",
  journal =      j-FORM-ASP-COMPUT,
  volume =       "22",
  number =       "3--4",
  pages =        "423--457",
  month =        may,
  year =         "2010",
  CODEN =        "FACME5",
  DOI =          "https://doi.org/10.1007/s00165-010-0148-1",
  ISSN =         "0934-5043 (print), 1433-299X (electronic)",
  ISSN-L =       "0934-5043",
  bibdate =      "Tue Mar 17 20:58:35 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/formaspcomput.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://link.springer.com/article/10.1007/s00165-010-0148-1",
  acknowledgement = ack-nhfb,
  fjournal =     "Formal Aspects of Computing",
  journal-URL =  "http://link.springer.com/journal/165",
}

@Article{Spoto:2010:MSL,
  author =       "Fausto Spoto and {\'E}tienne Payet",
  title =        "Magic-sets for localised analysis of {Java} bytecode",
  journal =      j-HIGHER-ORDER-SYMB-COMPUT,
  volume =       "23",
  number =       "1",
  pages =        "29--86",
  month =        mar,
  year =         "2010",
  CODEN =        "LSCOEX",
  ISSN =         "1388-3690 (print), 2212-0793 (electronic)",
  ISSN-L =       "1388-3690",
  bibdate =      "Tue Sep 6 16:06:25 MDT 2011",
  bibsource =    "http://springerlink.metapress.com/openurl.asp?genre=issue&issn=1388-3690&volume=23&issue=1;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://www.springerlink.com/openurl.asp?genre=article&issn=1388-3690&volume=23&issue=1&spage=29",
  acknowledgement = ack-nhfb,
  fjournal =     "Higher-Order and Symbolic Computation",
}

@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/java2010.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 {\em 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 {\em P\/}$_{{\em CLP \/
                 }}$ terminates, then {\em P\/} also terminates. Hence a
                 termination prover for constraint logic programs can be
                 applied to prove the termination of {\em 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,
  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{Spring:2010:RAI,
  author =       "Jesper Honig Spring and Filip Pizlo and Jean Privat
                 and Rachid Guerraoui and Jan Vitek",
  title =        "{Reflexes}: {Abstractions} for integrating highly
                 responsive tasks into {Java} applications",
  journal =      j-TECS,
  volume =       "10",
  number =       "1",
  pages =        "4:1--4:??",
  month =        aug,
  year =         "2010",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/1814539.1814543",
  ISSN =         "1539-9087 (print), 1558-3465 (electronic)",
  ISSN-L =       "1539-9087",
  bibdate =      "Mon Aug 30 15:29:45 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "Achieving submillisecond response times in a managed
                 language environment such as Java or C\# requires
                 overcoming significant challenges. In this article, we
                 propose Reflexes, a programming model and runtime
                 system infrastructure that lets developers seamlessly
                 mix highly responsive tasks and timing-oblivious Java
                 applications. Thus enabling gradual addition of
                 real-time features, to a non-real-time application
                 without having to resort to recoding the real-time
                 parts in a different language such as C or Ada.
                 Experiments with the Reflex prototype implementation
                 show that it is possible to run a real-time task with a
                 period of 45$ \mu $ s with an accuracy of 99.996\%
                 (only 0.001\% worse than the corresponding C
                 implementation) in the presence of garbage collection
                 and heavy load ordinary Java threads.",
  acknowledgement = ack-nhfb,
  articleno =    "4",
  fjournal =     "ACM Transactions on Embedded Computing Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?&idx=J840",
  keywords =     "Java virtual machine; memory management; Real-time
                 systems",
}

@Book{Stark:2010:BIA,
  author =       "Jonathan Stark",
  title =        "Building {iPhone} apps with {HTML}, {CSS}, and
                 {JavaScript}: Making {App Store} apps without
                 {Objective-C} or {Cocoa}",
  publisher =    pub-ORA-MEDIA,
  address =      pub-ORA-MEDIA:adr,
  pages =        "xv + 166",
  year =         "2010",
  ISBN =         "1-4493-8023-9, 0-596-80578-0",
  ISBN-13 =      "978-1-4493-8023-6, 978-0-596-80578-4",
  LCCN =         "????",
  bibdate =      "Wed Jul 28 09:12:55 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 z3950.bibsys.no:2100/BIBSYS",
  acknowledgement = ack-nhfb,
  subject =      "Cascading Style Sheets; HTML (document markup
                 language); computer software; development; iPhone
                 (Smartphone); programming; JavaScript (computer program
                 language)",
}

@Book{Stefanov:2010:JP,
  author =       "Stoyan Stefanov",
  title =        "{JavaScript} patterns",
  publisher =    pub-ORA,
  address =      pub-ORA:adr,
  pages =        "xvi + 216",
  year =         "2010",
  ISBN =         "1-4493-9911-8 (paperback), 0-596-80675-2 (paperback)",
  ISBN-13 =      "978-1-4493-9911-5 (paperback), 978-0-596-80675-0
                 (paperback)",
  LCCN =         "QA76.73.J39 S734 2010",
  bibdate =      "Wed Apr 27 11:12:26 MDT 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 melvyl.cdlib.org:210/CDL90",
  acknowledgement = ack-nhfb,
  subject =      "JavaScript (Computer program language); Software
                 patterns; Web site development",
}

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

@Article{Sutherland:2010:CTC,
  author =       "Dean F. Sutherland and William L. Scherlis",
  title =        "Composable thread coloring",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "5",
  pages =        "233--244",
  month =        may,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1693453.1693485",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Aug 31 22:39:18 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "This paper introduces the language-independent concept
                 of ``thread usage policy.'' Many multi-threaded
                 software systems contain policies that regulate
                 associations among threads, executable code, and
                 potentially shared state. A system, for example, may
                 constrain which threads are permitted to execute
                 particular code segments, usually as a means to
                 constrain those threads from accessing or writing
                 particular elements of state. These policies ensure
                 properties such as state confinement or reader/writer
                 constraints, often without recourse to locking or
                 transaction discipline.\par

                 Our approach allows developers to concisely document
                 their thread usage policies in a manner that enables
                 the use of sound scalable analysis to assess
                 consistency of policy and as-written code. This paper
                 identifies the key semantic concepts of our thread
                 coloring language and illustrates how to use its
                 succinct source-level annotations to express models of
                 thread usage policies, following established annotation
                 conventions for Java.\par

                 We have built a prototype static analysis tool,
                 implemented as an integrated development environment
                 plug-in (for the Eclipse IDE), that notifies developers
                 of discrepancies between policy annotations and
                 as-written code. Our analysis technique uses several
                 underlying algorithms based on abstract interpretation,
                 call-graphs, and type inference. The resulting overall
                 analysis is both sound and composable. We have used
                 this prototype analysis tool in case studies to model
                 and analyze more than a million lines of code.\par

                 Our validation process included field trials on a wide
                 variety of complex large-scale production code selected
                 by the host organizations. Our in-field experience led
                 us to focus on potential adoptability by real-world
                 developers. We have developed techniques that can
                 reduce annotation density to less than one line per
                 thousand lines of code (KLOC). In addition, the
                 prototype analysis tool supports an incremental and
                 iterative approach to modeling and analysis. This
                 approach enabled field trial partners to directly
                 target areas of greatest concern and to achieve useful
                 results within a few hours.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  keywords =     "annotation; Java; keywords: state consistency;
                 multicore; race conditions; state confinement; thread
                 policy",
}

@Article{Tatsubori:2010:EJT,
  author =       "Michiaki Tatsubori and Akihiko Tozawa and Toyotaro
                 Suzumura and Scott Trent and Tamiya Onodera",
  title =        "Evaluation of a just-in-time compiler retrofitted for
                 {PHP}",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "7",
  pages =        "121--132",
  month =        jul,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1735997.1736015",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Oct 8 17:55:01 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "Programmers who develop Web applications often use
                 dynamic scripting languages such as Perl, PHP, Python,
                 and Ruby. For general purpose scripting language usage,
                 interpreter-based implementations are efficient and
                 popular but the server-side usage for Web application
                 development implies an opportunity to significantly
                 enhance Web server throughput. This paper summarizes a
                 study of the optimization of PHP script processing. We
                 developed a PHP processor, P9, by adapting an existing
                 production-quality just-in-time (JIT) compiler for a
                 Java virtual machine, for which optimization
                 technologies have been well-established, especially for
                 server-side application. This paper describes and
                 contrasts microbenchmarks and SPECweb2005 benchmark
                 results for a well-tuned configuration of a traditional
                 PHP interpreter and our JIT compiler-based
                 implementation, P9. Experimental results with the
                 microbenchmarks show 2.5-9.5x advantage with P9, and
                 the SPECweb2005 measurements show about 20-30\%
                 improvements. These results show that the acceleration
                 of dynamic scripting language processing does matter in
                 a realistic Web application server environment. CPU
                 usage profiling shows our simple JIT compiler
                 introduction reduces the PHP core runtime overhead from
                 45\% to 13\% for a SPECweb2005 scenario, implying that
                 further improvements of dynamic compilers would provide
                 little additional return unless other major overheads
                 such as heavy memory copy between the language runtime
                 and Web server frontend are reduced.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  keywords =     "dynamic scripting languages; just-in-time compiler;
                 php",
}

@Article{Teng:2010:TPA,
  author =       "Q. M. Teng and H. C. Wang and Z. Xiao and P. F.
                 Sweeney and E. Duesterwald",
  title =        "{THOR}: a performance analysis tool for {Java}
                 applications running on multicore systems",
  journal =      j-IBM-JRD,
  volume =       "54",
  number =       "5",
  pages =        "4:1--4:17",
  month =        "????",
  year =         "2010",
  CODEN =        "IBMJAE",
  DOI =          "https://doi.org/10.1147/JRD.2010.2058481",
  ISSN =         "0018-8646 (print), 2151-8556 (electronic)",
  ISSN-L =       "0018-8646",
  bibdate =      "Sun Feb 20 14:29:19 MST 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://www.research.ibm.com/journal/",
  acknowledgement = ack-nhfb,
  fjournal =     "IBM Journal of Research and Development",
  journal-URL =  "http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=5288520",
}

@Article{Titzer:2010:ICR,
  author =       "Ben L. Titzer and Thomas W{\"u}rthinger and Doug Simon
                 and Marcelo Cintra",
  title =        "Improving compiler-runtime separation with {XIR}",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "7",
  pages =        "39--50",
  month =        jul,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1837854.1736005",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Oct 8 17:55:01 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "Intense research on virtual machines has highlighted
                 the need for flexible software architectures that allow
                 quick evaluation of new design and implementation
                 techniques. The interface between the compiler and
                 runtime system is a principal factor in the flexibility
                 of both components and is critical to enabling rapid
                 pursuit of new optimizations and features. Although
                 many virtual machines have demonstrated modularity for
                 many components, significant dependencies often remain
                 between the compiler and the runtime system components
                 such as the object model and memory management system.
                 This paper addresses this challenge with a carefully
                 designed strict compiler-runtime interface and the XIR
                 language. Instead of the compiler backend lowering
                 object operations to machine operations using
                 hard-wired runtime-specific logic, XIR allows the
                 runtime system to implement this logic, simultaneously
                 simplifying and separating the backend from
                 runtime-system details. In this paper we describe the
                 design and implementation of this compiler-runtime
                 interface and the XIR language in the C1X dynamic
                 compiler, a port of the HotSpotTM Client compiler. Our
                 results show a significant reduction in backend
                 complexity with XIR and an overall reduction in the
                 compiler-runtime interface complexity while still
                 generating comparable quality code with only minor
                 impact on compilation time.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  keywords =     "compilers; intermediate representations; java; JIT;
                 lowering; object model; register allocation; runtime
                 interface; software architecture; virtual machines",
}

@Article{Torlak:2010:MCA,
  author =       "Emina Torlak and Mandana Vaziri and Julian Dolby",
  title =        "{MemSAT}: checking axiomatic specifications of memory
                 models",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "6",
  pages =        "341--350",
  month =        jun,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1806596.1806635",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Oct 8 17:53:18 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "Memory models are hard to reason about due to their
                 complexity, which stems from the need to strike a
                 balance between ease-of-programming and allowing
                 compiler and hardware optimizations. In this paper, we
                 present an automated tool, MemSAT, that helps in
                 debugging and reasoning about memory models. Given an
                 axiomatic specification of a memory model and a
                 multi-threaded test program containing assertions,
                 MemSAT outputs a trace of the program in which both the
                 assertions and the memory model axioms are satisfied,
                 if one can be found. The tool is fully automatic and is
                 based on a SAT solver. If it cannot find a trace, it
                 outputs a minimal subset of the memory model and
                 program constraints that are unsatisfiable. We used
                 MemSAT to check several existing memory models against
                 their published test cases, including the current Java
                 Memory Model by Manson et al. and a revised version of
                 it by Sevcik and Aspinall. We found subtle
                 discrepancies between what was expected and the actual
                 results of test programs.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  keywords =     "axiomatic specifications; bounded model checking;
                 memory models; sat",
}

@Article{Ugawa:2010:IRB,
  author =       "Tomoharu Ugawa and Hideya Iwasaki and Taiichi Yuasa",
  title =        "Improved replication-based incremental garbage
                 collection for embedded systems",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "8",
  pages =        "73--82",
  month =        aug,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1806651.1806664",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Oct 8 17:55:48 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "We have developed an incremental compacting garbage
                 collector for embedded Java systems. The collector
                 divides the heap into equal sized pages and uses the
                 segregated free lists for fast allocation. Collectors
                 that have such a heap layout have a problem of
                 fragmentation in allocating objects larger than the
                 page size. We solve this problem by using the
                 replication-based incremental compaction. The compactor
                 evacuates all objects in one area, the evacuation area,
                 of the heap, thereby creating a large chunk of free
                 space. We developed an algorithm for choosing the
                 evacuation area that effectively cures fragmentation.
                 The compactor does not use any read-barriers. Instead,
                 it uses a technique similar to the replication-based
                 incremental copying collection. This needs forwarding
                 pointers for all evacuated objects. Rather than
                 introducing an extra field for each object, we use a
                 hash table to store forwarding pointers.\par

                 Evaluation of this garbage collector implemented in
                 Sun's J2ME Java Virtual Machine showed that all the
                 benchmarks used were able to run without memory
                 starvation using the heap sizes of only 151\%-286\% of
                 the maximum amount of live data plus 8 KB of the hash
                 table. Experiments on a desktop computer, though it is
                 not a platform for embedded systems, showed that the
                 maximum pause time was shorter than 200 &\#956;s, which
                 was comparable to that of our implementation of the
                 snapshot-at-the-beginning collector without compaction.
                 On an ARM processor, the runtime overhead was 1\%-16\%
                 with 8.0\% on average compared to the mark-sweep
                 collector.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  keywords =     "compaction; embedded systems; fragmentation; garbage
                 collection; real-time garbage collection",
}

@Article{Upadhyaya:2010:UDS,
  author =       "Gautam Upadhyaya and Samuel P. Midkiff and Vijay S.
                 Pai",
  title =        "Using data structure knowledge for efficient lock
                 generation and strong atomicity",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "5",
  pages =        "281--292",
  month =        may,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1693453.1693490",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Aug 31 22:39:18 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "To achieve high-performance on multicore systems,
                 sharedmemory parallel languages must efficiently
                 implement atomic operations. The commonly used and
                 studied paradigms for atomicity are fine-grained
                 locking, which is both difficult to program and
                 error-prone; optimistic software transactions, which
                 require substantial overhead to detect and recover from
                 atomicity violations; and compiler-generation of locks
                 from programmer-specified atomic sections, which leads
                 to serialization whenever imprecise pointer analysis
                 suggests the mere possibility of a conflicting
                 operation. This paper presents a new strategy for
                 compiler-generated locking that uses data structure
                 knowledge to facilitate more precise alias and lock
                 generation analyses and reduce unnecessary
                 serialization. Implementing and evaluating these ideas
                 in the Java language shows that the new strategy
                 achieves eight-thread speedups of 0.83 to 5.9 for the
                 five STAMP benchmarks studied, outperforming software
                 transactions on all but one benchmark, and nearly
                 matching programmer-specified fine-grained locks on all
                 but one benchmark. The results also indicate that
                 compiler knowledge of data structures improves the
                 effectiveness of compiler analysis, boosting
                 eight-thread performance by up to 300\%. Further, the
                 new analysis allows for software support of strong
                 atomicity with less than 1\% overhead for two
                 benchmarks and less than 20\% for three others. The
                 strategy also nearly matches the performance of
                 programmer-specified fine-grained locks for the
                 SPECjbb2000 benchmark, which has traditionally not been
                 amenable to static analyses.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  keywords =     "automatic lock generation; parallel programming;
                 transactional memory",
}

@Article{VanCutsem:2010:PDP,
  author =       "Tom {Van Cutsem} and Mark S. Miller",
  title =        "Proxies: design principles for robust object-oriented
                 intercession {APIs}",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "12",
  pages =        "59--72",
  month =        dec,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1899661.1869638",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Wed Dec 15 10:25:15 MST 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "Proxies are a powerful approach to implement
                 meta-objects in object-oriented languages without
                 having to resort to metacircular interpretation. We
                 introduce such a meta-level API based on proxies for
                 Javascript. We simultaneously introduce a set of design
                 principles that characterize such APIs in general, and
                 compare similar APIs of other languages in terms of
                 these principles. We highlight how principled
                 proxy-based APIs improve code robustness by avoiding
                 interference between base and meta-level code that
                 occur in more common reflective intercession
                 mechanisms.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Book{VanderHart:2010:PC,
  author =       "Luke VanderHart and Stuart Sierra",
  title =        "Practical {Clojure}",
  publisher =    pub-APRESS,
  address =      pub-APRESS:adr,
  pages =        "xvi + 210",
  year =         "2010",
  ISBN =         "1-4302-7231-7, 1-4302-7230-9 (e-book)",
  ISBN-13 =      "978-1-4302-7231-1, 978-1-4302-7230-4 (e-book)",
  LCCN =         "????",
  bibdate =      "Fri Nov 23 10:33:38 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/common-lisp.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 z3950.loc.gov:7090/Voyager",
  series =       "The expert's voice in open source",
  acknowledgement = ack-nhfb,
  subject =      "Java virtual machine; Clojure (Computer program
                 language)",
}

@Book{VanLoan:2010:ITC,
  author =       "Charles F. {Van Loan} and K.-Y. Daisy Fan",
  title =        "Insight through computing: a {MATLAB} introduction to
                 computational science and engineering",
  publisher =    pub-SIAM,
  address =      pub-SIAM:adr,
  pages =        "xviii + 434",
  year =         "2010",
  ISBN =         "0-89871-691-8",
  ISBN-13 =      "978-0-89871-691-7",
  LCCN =         "QA297 .V25 2010",
  bibdate =      "Fri Nov 16 10:03:00 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/matlab.bib;
                 https://www.math.utah.edu/pub/tex/bib/numana2010.bib;
                 z3950.loc.gov:7090/Voyager",
  URL =          "http://www.loc.gov/catdir/enhancements/fy1007/2009030277-b.html;
                 http://www.loc.gov/catdir/enhancements/fy1007/2009030277-d.html;
                 http://www.loc.gov/catdir/enhancements/fy1007/2009030277-t.html",
  acknowledgement = ack-nhfb,
  subject =      "Numerical analysis; Data processing; Science; Computer
                 simulation; Engineering mathematics; MATLAB",
  tableofcontents = "Preface \\
                 MATLAB glossary \\
                 Programming topics \\
                 Software \\
                 1. From formula to program \\
                 2. Limits and error \\
                 3. Approximation with fractions \\
                 4. The discrete versus the continuous \\
                 5. Abstraction \\
                 6. Randomness \\
                 7. The second dimension \\
                 8. Reordering \\
                 9. Search \\
                 10. Points, polygons and circles \\
                 11. Text file processing \\
                 12. The matrix: part II \\
                 13. Acoustic file processing \\
                 14. Divide and conquer \\
                 15. Optimization \\
                 Appendix A. Refined graphics \\
                 Appendix B. Mathematical facts \\
                 Appendix C. MATLAB, Java, and C \\
                 Appendix D. Exit interview \\
                 Index",
}

@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/java2010.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,
  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{Vechev:2010:PPC,
  author =       "Martin Vechev and Eran Yahav and Greta Yorsh",
  title =        "{PHALANX}: parallel checking of expressive heap
                 assertions",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "8",
  pages =        "41--50",
  month =        aug,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1837855.1806658",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Oct 8 17:55:48 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "Unrestricted use of heap pointers makes software
                 systems difficult to understand and to debug. To
                 address this challenge, we developed PHALANX -- a
                 practical framework for dynamically checking expressive
                 heap properties such as ownership, sharing and
                 reachability. PHALANX uses novel parallel algorithms to
                 efficiently check a wide range of heap properties
                 utilizing the available cores.\par

                 PHALANX runtime is implemented on top of IBM's Java
                 production virtual machine. This has enabled us to
                 apply our new techniques to real world software. We
                 checked expressive heap properties in various scenarios
                 and found the runtime support to be valuable for
                 debugging and program understanding. Further, our
                 experimental results on DaCapo and other benchmarks
                 indicate that evaluating heap queries using parallel
                 algorithms can lead to significant performance
                 improvements, often resulting in linear speedups as the
                 number of cores increases.\par

                 To encourage adoption by programmers, we extended an
                 existing JML compiler to translate expressive JML
                 assertions about the heap into their efficient
                 implementation provided by PHALANX. To debug her
                 program, a programmer can annotate it with expressive
                 heap assertions in JML, that are efficiently checked by
                 PHALANX.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  keywords =     "ownership; parallel garbage collector; virtual
                 machine",
}

@Article{Villazon:2010:ARA,
  author =       "Alex Villaz{\'o}n and Walter Binder and Danilo
                 Ansaloni and Philippe Moret",
  title =        "Advanced runtime adaptation for {Java}",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "2",
  pages =        "85--94",
  month =        feb,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1621607.1621621",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Aug 31 22:37:56 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "Dynamic aspect-oriented programming (AOP) enables
                 runtime adaptation of aspects, which is important for
                 building sophisticated, aspect-based software
                 engineering tools, such as adaptive profilers or
                 debuggers that dynamically modify instrumentation code
                 in response to user interactions. Today, many AOP
                 frameworks for Java, notably AspectJ, focus on aspect
                 weaving at compile-time or at load-time, and offer only
                 limited support for aspect adaptation and reweaving at
                 runtime. In this paper, we introduce HotWave, an AOP
                 framework based on AspectJ for standard Java Virtual
                 Machines (JVMs). HotWave supports dynamic (re)weaving
                 of previously loaded classes, and it ensures that all
                 classes loaded in a JVM can be (re)woven, including the
                 classes of the standard Java class library. HotWave
                 features a novel mechanism for inter-advice
                 communication, enabling efficient data passing between
                 advices that are woven into the same method. We explain
                 HotWave's programming model and discuss our
                 implementation techniques. As case study, we present an
                 adaptive, aspect-based profiler that leverages
                 HotWave's distinguishing features.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  keywords =     "AspectJ; bytecode instrumentation; code hotswapping;
                 dynamic aspect-oriented programming; Java Virtual
                 Machine; runtime aspect adaptation and (re)weaving",
}

@Article{Villazon:2010:HCA,
  author =       "Alex Villaz{\'o}n and Walter Binder and Danilo
                 Ansaloni and Philippe Moret",
  title =        "{HotWave}: creating adaptive tools with dynamic
                 aspect-oriented programming in {Java}",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "2",
  pages =        "95--98",
  month =        feb,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1621607.1621622",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Aug 31 22:37:56 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "Developing tools for profiling, debugging, testing,
                 and reverse engineering is error-prone, time-consuming,
                 and therefore costly when using low-level techniques,
                 such as bytecode instrumentation. As a solution to
                 these problems, we promote tool development in Java
                 using high-level aspect-oriented programming (AOP). We
                 demonstrate that the use of aspects yields compact
                 tools that are easy to develop and extend. As enabling
                 technology, we rely on HotWave, a new tool for dynamic
                 and comprehensive aspect weaving. HotWave reconciles
                 compatibility with existing virtual machine and AOP
                 technologies. It provides support for runtime
                 adaptation of aspects and reweaving of previously
                 loaded code, as well as the ability to weave aspects
                 into all methods executing in a Java Virtual Machine,
                 including methods in the standard Java class library.
                 HotWave also features a new mechanism for efficiently
                 passing data between advices that are woven into the
                 same method. We demonstrate the benefits of HotWave's
                 distinguishing features with two case studies in the
                 area of profiling.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  keywords =     "AspectJ; bytecode instrumentation; code hotswapping;
                 dynamic aspect-oriented programming; Java Virtual
                 Machine; profiling; runtime weaving",
}

@Article{Wehr:2010:JBP,
  author =       "Stefan Wehr and Peter Thiemann",
  title =        "{JavaGI} in the battlefield: practical experience with
                 generalized interfaces",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "2",
  pages =        "65--74",
  month =        feb,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1621607.1621619",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Aug 31 22:37:56 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "Generalized interfaces are an extension of the
                 interface concept found in object-oriented languages
                 such as Java or C\#. The extension is inspired by
                 Haskell's type classes. It supports retroactive and
                 type-conditional interface implementations, binary
                 methods, symmetric multimethods, interfaces over
                 families of types, and static interface
                 methods.\par

                 This article reports practical experience with
                 generalized interfaces as implemented in the JavaGI
                 language. Several real-world case studies demonstrate
                 how generalized interfaces provide solutions to
                 extension and integration problems with components in
                 binary form, how they make certain design patterns
                 redundant, and how they eliminate various run-time
                 errors. In each case study, the use of JavaGI results
                 in elegant and highly readable code.\par

                 Furthermore, the article discusses the implementation
                 of a compiler and a run-time system for JavaGI.
                 Benchmarks show that our implementation offers
                 acceptable performance.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  keywords =     "case studies; external methods; JavaGI; multimethods;
                 retroactive interface implementation",
}

@Article{Welch:2010:ABS,
  author =       "Peter Welch and Neil Brown and James Moores and Kevin
                 Chalmers and Bernhard Sputh",
  title =        "Alting barriers: synchronisation with choice in {Java}
                 using {JCSP}",
  journal =      j-CCPE,
  volume =       "22",
  number =       "8",
  pages =        "1049--1062",
  day =          "10",
  month =        jun,
  year =         "2010",
  CODEN =        "CCPEBO",
  DOI =          "https://doi.org/10.1002/cpe.1471",
  ISSN =         "1532-0626 (print), 1532-0634 (electronic)",
  ISSN-L =       "1532-0626",
  bibdate =      "Mon Dec 5 10:08:44 MST 2011",
  bibsource =    "http://www.interscience.wiley.com/jpages/1532-0626;
                 https://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Concurrency and Computation: Prac\-tice and
                 Experience",
  journal-URL =  "http://www.interscience.wiley.com/jpages/1532-0626",
  onlinedate =   "1 Mar 2010",
}

@Article{Wendykier:2010:PCH,
  author =       "Piotr Wendykier and James G. Nagy",
  title =        "{Parallel Colt}: a High-Performance {Java} Library for
                 Scientific Computing and Image Processing",
  journal =      j-TOMS,
  volume =       "37",
  number =       "3",
  pages =        "31:1--31:22",
  month =        sep,
  year =         "2010",
  CODEN =        "ACMSCU",
  DOI =          "https://doi.org/10.1145/1824801.1824809",
  ISSN =         "0098-3500 (print), 1557-7295 (electronic)",
  ISSN-L =       "0098-3500",
  bibdate =      "Mon Sep 27 10:15:50 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "Major breakthroughs in chip and software design have
                 been observed for the last nine years. In October 2001,
                 IBM released the world's first multicore processor:
                 POWER4. Six years later, in February 2007, NVIDIA made
                 a public release of CUDA SDK, a set of development
                 tools to write algorithms for execution on Graphic
                 Processing Units (GPUs). Although software vendors have
                 started working on parallelizing their products, the
                 vast majority of existing code is still sequential and
                 does not effectively utilize modern multicore CPUs and
                 manycore GPUs.\par

                 This article describes Parallel Colt, a multithreaded
                 Java library for scientific computing and image
                 processing. In addition to describing the design and
                 functionality of Parallel Colt, a comparison to MATLAB
                 is presented. Two ImageJ plugins for iterative image
                 deblurring and motion correction of PET brain images
                 are described as typical applications of this library.
                 Performance comparisons with MATLAB, including GPU
                 computations via AccelerEyes' Jacket toolbox are also
                 given.",
  acknowledgement = ack-nhfb,
  articleno =    "31",
  fjournal =     "ACM Transactions on Mathematical Software",
  journal-URL =  "http://portal.acm.org/toc.cfm?idx=J782",
  keywords =     "Deconvolution; FFT; inverse problems; iterative
                 methods; motion correction; multithreading; PET;
                 regularization",
}

@Article{Westbrook:2010:MJM,
  author =       "Edwin Westbrook and Mathias Ricken and Jun Inoue and
                 Yilong Yao and Tamer Abdelatif and Walid Taha",
  title =        "{Mint}: {Java} multi-stage programming using weak
                 separability",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "6",
  pages =        "400--411",
  month =        jun,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1809028.1806642",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Oct 8 17:53:18 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "Multi-stage programming (MSP) provides a disciplined
                 approach to run-time code generation. In the purely
                 functional setting, it has been shown how MSP can be
                 used to reduce the overhead of abstractions, allowing
                 clean, maintainable code without paying performance
                 penalties. Unfortunately, MSP is difficult to combine
                 with imperative features, which are prevalent in
                 mainstream languages. The central difficulty is scope
                 extrusion, wherein free variables can inadvertently be
                 moved outside the scopes of their binders. This paper
                 proposes a new approach to combining MSP with
                 imperative features that occupies a 'sweet spot' in the
                 design space in terms of how well useful MSP
                 applications can be expressed and how easy it is for
                 programmers to understand. The key insight is that
                 escapes (or 'anti-quotes') must be weakly separable
                 from the rest of the code, i.e. the computational
                 effects occurring inside an escape that are visible
                 outside the escape are guaranteed to not contain code.
                 To demonstrate the feasibility of this approach, we
                 formalize a type system based on Lightweight Java which
                 we prove sound, and we also provide an implementation,
                 called Mint, to validate both the expressivity of the
                 type system and the effect of staging on the
                 performance of Java programs.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  keywords =     "java; multi-stage programming; multi-staged languages;
                 type systems",
}

@Article{Wimmer:2010:AFD,
  author =       "Christian Wimmer and Hanspeter M{\"o}ssenb{\"o}sck",
  title =        "Automatic feedback-directed object fusing",
  journal =      j-TACO,
  volume =       "7",
  number =       "2",
  pages =        "7:1--7:??",
  month =        sep,
  year =         "2010",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/1839667.1839669",
  ISSN =         "1544-3566 (print), 1544-3973 (electronic)",
  ISSN-L =       "1544-3566",
  bibdate =      "Sat Oct 2 18:05:46 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "Object fusing is an optimization that embeds certain
                 referenced objects into their referencing object. The
                 order of objects on the heap is changed in such a way
                 that objects that are accessed together are placed next
                 to each other in memory. Their offset is then fixed,
                 that is, the objects are colocated, allowing field
                 loads to be replaced by address arithmetic. Array
                 fusing specifically optimizes arrays, which are
                 frequently used for the implementation of dynamic data
                 structures. Therefore, the length of arrays often
                 varies, and fields referencing such arrays have to be
                 changed. An efficient code pattern detects these
                 changes and allows the optimized access of such
                 fields.\par

                 We integrated these optimizations into Sun
                 Microsystems' Java HotSpot\TM{} VM. The analysis is
                 performed automatically at runtime, requires no actions
                 on the part of the programmer, and supports dynamic
                 class loading. To safely eliminate a field load, the
                 colocation of the object that holds the field and the
                 object that is referenced by the field must be
                 guaranteed. Two preconditions must be satisfied: The
                 objects must be allocated at the same time, and the
                 field must not be overwritten later. These
                 preconditions are checked by the just-in-time compiler
                 to avoid an interprocedural data flow analysis. The
                 garbage collector ensures that groups of colocated
                 objects are not split by copying groups as a whole. The
                 evaluation shows that the dynamic approach successfully
                 identifies and optimizes frequently accessed fields for
                 several benchmarks with a low compilation and analysis
                 overhead. It leads to a speedup of up to 76\% for
                 simple benchmarks and up to 6\% for complex
                 workloads.",
  acknowledgement = ack-nhfb,
  articleno =    "7",
  fjournal =     "ACM Transactions on Architecture and Code Optimization
                 (TACO)",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J924",
  keywords =     "cache performance; garbage collection; Java;
                 just-in-time compilation; object colocation; object
                 fusing; object inlining; optimization",
}

@Article{Witman:2010:TBR,
  author =       "Paul D. Witman and Terry Ryan",
  title =        "Think big for reuse",
  journal =      j-CACM,
  volume =       "53",
  number =       "1",
  pages =        "142--147",
  month =        jan,
  year =         "2010",
  CODEN =        "CACMA2",
  DOI =          "https://doi.org/10.1145/1629175.1629209",
  ISSN =         "0001-0782 (print), 1557-7317 (electronic)",
  ISSN-L =       "0001-0782",
  bibdate =      "Thu Feb 4 17:12:32 MST 2010",
  bibsource =    "http://www.acm.org/pubs/contents/journals/cacm/;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "Many organizations are successful with software reuse
                 at fine to medium granularities -- ranging from
                 objects, subroutines, and components through software
                 product lines. However, relatively little has been
                 published on very large-grained reuse. One example of
                 this type of large-grained reuse might be that of an
                 entire Internet banking system (applications and
                 infrastructure) reused in business units all over the
                 world. In contrast, 'large scale' software reuse in
                 current research generally refers to systems that reuse
                 a large number of smaller components, or that perhaps
                 reuse subsystems. In this article, we explore a case of
                 an organization with an internal development group that
                 has been very successful with large-grained software
                 reuse.\par

                 BigFinancial, and the BigFinancial Technology Center
                 (BTC) in particular, have created a number of software
                 systems that have been reused in multiple businesses
                 and in multiple countries. BigFinancial and BTC thus
                 provided a rich source of data for case studies to look
                 at the characteristics of those projects and why they
                 have been successful, as well as to look at projects
                 that have been less successful and to understand what
                 has caused those results and what might be done
                 differently to prevent issues in the future. The
                 research is focused on technology, process, and
                 organizational elements of the development process,
                 rather than on specific product features and
                 functions.\par

                 Supporting reuse at a large-grained level may help to
                 alleviate some of the issues that occur in more
                 traditional reuse programs, which tend to be
                 finer-grained. In particular, because BigFinancial was
                 trying to gain commonality in business processes and
                 operating models, reuse of large-grained components was
                 more closely aligned with its business goals. This same
                 effect may well not have happened with finer-grained
                 reuse, due to the continued ability of business units
                 to more readily pick and choose components for
                 reuse.\par

                 BTC is a technology development unit of BigFinancial,
                 with operations in both the eastern and western US.
                 Approximately 500 people are employed by BTC, reporting
                 ultimately through a single line manager responsible to
                 the Global Retail Business unit head of BigFinancial.
                 BTC is organized to deliver both products and
                 infrastructure components to BigFinancial, and its
                 product line has through the years included consumer
                 Internet banking services, teller systems, ATM
                 software, and network management tools. BigFinancial
                 has its U.S. operations headquartered in the eastern
                 U.S., and employs more than 8,000 technologists
                 worldwide.\par

                 In cooperation with BTC, we selected three cases for
                 further study from a pool of about 25. These cases were
                 the Java Banking Toolkit (JBT) and its related
                 application systems, the Worldwide Single Signon (WSSO)
                 subsystem, and the BigFinancial Message Switch (BMS).",
  acknowledgement = ack-nhfb,
  fjournal =     "Communications of the ACM",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J79",
}

@Article{Xu:2010:DIU,
  author =       "Guoqing Xu and Atanas Rountev",
  title =        "Detecting inefficiently-used containers to avoid
                 bloat",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "6",
  pages =        "160--173",
  month =        jun,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1806596.1806616",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Oct 8 17:53:18 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "Runtime bloat degrades significantly the performance
                 and scalability of software systems. An important
                 source of bloat is the inefficient use of containers.
                 It is expensive to create inefficiently-used containers
                 and to invoke their associated methods, as this may
                 ultimately execute large volumes of code, with call
                 stacks dozens deep, and allocate many temporary
                 objects.\par

                 This paper presents practical static and dynamic tools
                 that can find inappropriate use of containers in Java
                 programs. At the core of these tools is a base static
                 analysis that identifies, for each container, the
                 objects that are added to this container and the key
                 statements (i.e., heap loads and stores) that achieve
                 the semantics of common container operations such as
                 {\em ADD\/} and {\em GET}. The static tool finds
                 problematic uses of containers by considering the
                 nesting relationships among the loops where these {\em
                 semantics-achieving statements\/} are located, while
                 the dynamic tool can instrument these statements and
                 find inefficiencies by profiling their execution
                 frequencies.\par

                 The high precision of the base analysis is achieved by
                 taking advantage of a context-free language
                 (CFL)-reachability formulation of points-to analysis
                 and by accounting for container-specific properties. It
                 is demand-driven and client-driven, facilitating
                 refinement specific to each queried container object
                 and increasing scalability. The tools built with the
                 help of this analysis can be used both to avoid the
                 creation of container-related performance problems
                 early during development, and to help with diagnosis
                 when problems are observed during tuning. Our
                 experimental results show that the static tool has a
                 low false positive rate and produces more relevant
                 information than its dynamic counterpart. Further case
                 studies suggest that significant optimization
                 opportunities can be found by focusing on
                 statically-identified containers for which high
                 allocation frequency is observed at run time.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  keywords =     "cfl reachability; container bloat; points-to
                 analysis",
}

@Article{Xu:2010:FLU,
  author =       "Guoqing Xu and Nick Mitchell and Matthew Arnold and
                 Atanas Rountev and Edith Schonberg and Gary Sevitsky",
  title =        "Finding low-utility data structures",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "6",
  pages =        "174--186",
  month =        jun,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1806596.1806617",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Oct 8 17:53:18 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "Many opportunities for easy, big-win, program
                 optimizations are missed by compilers. This is
                 especially true in highly layered Java applications.
                 Often at the heart of these missed optimization
                 opportunities lie computations that, with great
                 expense, produce data values that have little impact on
                 the program's final output. Constructing a new date
                 formatter to format every date, or populating a large
                 set full of expensively constructed structures only to
                 check its size: these involve costs that are out of
                 line with the benefits gained. This disparity between
                 the formation costs and accrued benefits of data
                 structures is at the heart of much runtime
                 bloat.\par

                 We introduce a run-time analysis to discover these {\em
                 low-utility\/} data structures. The analysis employs
                 dynamic thin slicing, which naturally associates costs
                 with value flows rather than raw data flows. It
                 constructs a model of the incremental, hop-to-hop,
                 costs and benefits of each data structure. The analysis
                 then identifies suspicious structures based on
                 imbalances of its incremental costs and benefits. To
                 decrease the memory requirements of slicing, we
                 introduce {\em abstract dynamic thin slicing}, which
                 performs thin slicing over bounded abstract domains. We
                 have modified the IBM J9 commercial JVM to implement
                 this approach.\par

                 We demonstrate two client analyses: one that finds
                 objects that are expensive to construct but are not
                 necessary for the forward execution, and second that
                 pinpoints ultimately-dead values. We have successfully
                 applied them to large-scale and long-running Java
                 applications. We show that these analyses are effective
                 at detecting operations that have unbalanced costs and
                 benefits.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  keywords =     "abstract dynamic thin slicing; cost benefit analysis;
                 memory bloat",
}

@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/java2010.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,
  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{Yang:2010:JIP,
  author =       "L. Yang and M. R. Poppleton",
  title =        "{Java} implementation platform for the integrated
                 state- and event-based specification in {PROB}",
  journal =      j-CCPE,
  volume =       "22",
  number =       "8",
  pages =        "1007--1022",
  day =          "10",
  month =        jun,
  year =         "2010",
  CODEN =        "CCPEBO",
  DOI =          "https://doi.org/10.1002/cpe.1425",
  ISSN =         "1532-0626 (print), 1532-0634 (electronic)",
  ISSN-L =       "1532-0626",
  bibdate =      "Mon Dec 5 10:08:44 MST 2011",
  bibsource =    "http://www.interscience.wiley.com/jpages/1532-0626;
                 https://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Concurrency and Computation: Prac\-tice and
                 Experience",
  journal-URL =  "http://www.interscience.wiley.com/jpages/1532-0626",
  onlinedate =   "29 Oct 2009",
}

@Book{Zakas:2010:HPJ,
  author =       "Nicholas C. Zakas",
  title =        "High performance {JavaScript}",
  publisher =    pub-ORA,
  address =      pub-ORA:adr,
  pages =        "xviii + 209",
  year =         "2010",
  ISBN =         "0-596-80279-x, 1-4493-8230-4",
  ISBN-13 =      "978-0-596-80279-0, 978-1-4493-8230-8",
  LCCN =         "????",
  bibdate =      "Wed Apr 27 11:14:30 MDT 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 z3950.bibsys.no:2100/BIBSYS",
  acknowledgement = ack-nhfb,
  subject =      "Web servers; World Wide Web; JavaScript (Computer
                 program language); Document Object Model (Web site
                 development technology)",
}

@Article{Zerzelidis:2010:FFS,
  author =       "Alexandros Zerzelidis and Andy Wellings",
  title =        "A framework for flexible scheduling in the {RTSJ}",
  journal =      j-TECS,
  volume =       "10",
  number =       "1",
  pages =        "3:1--3:??",
  month =        aug,
  year =         "2010",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/1814539.1814542",
  ISSN =         "1539-9087 (print), 1558-3465 (electronic)",
  ISSN-L =       "1539-9087",
  bibdate =      "Mon Aug 30 15:29:45 MDT 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "This article presents a viable solution to introducing
                 flexible scheduling in the Real-Time specification for
                 Java (RTSJ), in the form of a flexible scheduling
                 framework. The framework allows the concurrent use of
                 multiple application-defined scheduling policies, each
                 scheduling a subset of the total set of threads.
                 Moreover, all threads, regardless of the policy under
                 which they are scheduled, are permitted to share common
                 resources. Thus, the framework can accommodate a
                 variety of interworking applications (soft, firm, and
                 hard) running under the RTSJ. The proposed approach is
                 a two-level scheduling framework, where the first level
                 is the RTSJ priority scheduler and the second level is
                 under application control. This article describes the
                 framework's protocol, examines the different types of
                 scheduling policies that can be supported, and
                 evaluates the proposed framework by measuring its
                 execution cost. A description of an application-defined
                 Earliest-Deadline-First (EDF) scheduler illustrates how
                 the interface can be used. Minimum backward-compatible
                 changes to the RTSJ specification are discussed to
                 motivate the required interface. The only assumptions
                 made about the underlying real-time operating system is
                 that it supports preemptive priority-based dispatching
                 of threads and that changes to priorities have
                 immediate effect.",
  acknowledgement = ack-nhfb,
  articleno =    "3",
  fjournal =     "ACM Transactions on Embedded Computing Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?&idx=J840",
  keywords =     "flexible scheduling; RTSJ; Scheduling framework",
}

@Article{Zibin:2010:OIG,
  author =       "Yoav Zibin and Alex Potanin and Paley Li and Mahmood
                 Ali and Michael D. Ernst",
  title =        "Ownership and immutability in generic {Java}",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "10",
  pages =        "598--617",
  month =        oct,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1932682.1869509",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Wed Jan 26 15:13:46 MST 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Aiello:2011:JBA,
  author =       "Francesco Aiello and Giancarlo Fortino and Raffaele
                 Gravina and Antonio Guerrieri",
  title =        "A {Java}-Based Agent Platform for Programming Wireless
                 Sensor Networks",
  journal =      j-COMP-J,
  volume =       "54",
  number =       "3",
  pages =        "439--454",
  month =        mar,
  year =         "2011",
  CODEN =        "CMPJA6",
  DOI =          "https://doi.org/10.1093/comjnl/bxq019",
  ISSN =         "0010-4620 (print), 1460-2067 (electronic)",
  ISSN-L =       "0010-4620",
  bibdate =      "Fri Feb 25 15:49:03 MST 2011",
  bibsource =    "http://comjnl.oxfordjournals.org/content/54/3.toc;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://comjnl.oxfordjournals.org/content/54/3/439.full.pdf+html",
  acknowledgement = ack-nhfb,
  fjournal =     "Computer Journal",
  journal-URL =  "http://comjnl.oxfordjournals.org/",
  onlinedate =   "February 22, 2010",
}

@Article{Aigner:2011:STM,
  author =       "Martin Aigner and Andreas Haas and Christoph M. Kirsch
                 and Michael Lippautz and Ana Sokolova and Stephanie
                 Stroka and Andreas Unterweger",
  title =        "Short-term memory for self-collecting mutators",
  journal =      j-SIGPLAN,
  volume =       "46",
  number =       "11",
  pages =        "99--108",
  month =        nov,
  year =         "2011",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2076022.1993493",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Dec 15 07:46:57 MST 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "ISMM '11 conference proceedings.",
  abstract =     "We propose a new memory model called short-term memory
                 for managing objects on the heap. In contrast to the
                 traditional persistent memory model for heap
                 management, objects in short-term memory expire after a
                 finite amount of time, which makes deallocation
                 unnecessary. Instead, expiration of objects may be
                 extended, if necessary, by refreshing. We have
                 developed a concurrent, incremental, and non-moving
                 implementation of short-term memory for explicit
                 refreshing called self-collecting mutators that is
                 based on programmer-controlled time and integrated into
                 state-of-the-art runtimes of three programming
                 languages: C, Java, and Go. All memory management
                 operations run in constant time without acquiring any
                 locks modulo the underlying allocators.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Arnold:2011:AOJ,
  author =       "Matthew Arnold and Stephen Fink and David Grove and
                 Michael Hind and Peter F. Sweeney",
  title =        "Adaptive optimization in the {Jalapeno JVM}",
  journal =      j-SIGPLAN,
  volume =       "46",
  number =       "4",
  pages =        "65--83",
  month =        apr,
  year =         "2011",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1988042.1988048",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue May 24 10:55:07 MDT 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "Future high-performance virtual machines will improve
                 performance through sophisticated online
                 feedback-directed optimizations. This paper presents
                 the architecture of the Jalapeno Adaptive Optimization
                 System, a system to support leading-edge virtual
                 machine technology and enable ongoing research on
                 online feedback-directed optimizations. We describe the
                 extensible system architecture, based on a federation
                 of threads with asynchronous communication. We present
                 an implementation of the general architecture that
                 supports adaptive multi-level optimization based purely
                 on statistical sampling. We empirically demonstrate
                 that this profiling technique has low overhead and can
                 improve startup and steady-state performance, even
                 without the presence of online feedback-directed
                 optimizations. The paper also describes and evaluates
                 an online feedback-directed inlining optimization based
                 on statistical edge sampling.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Arslan:2011:JPM,
  author =       "G{\"u}ven{\c{c}} Arslan and Ilknur {\"O}zmen",
  title =        "A {JAVA} program for the multivariate {$ Z_p $} and {$
                 C_p $} tests and its application",
  journal =      j-J-COMPUT-APPL-MATH,
  volume =       "235",
  number =       "16",
  pages =        "4729--4735",
  day =          "15",
  month =        jun,
  year =         "2011",
  CODEN =        "JCAMDI",
  DOI =          "https://doi.org/10.1016/j.cam.2010.08.035",
  ISSN =         "0377-0427 (print), 1879-1778 (electronic)",
  ISSN-L =       "0377-0427",
  bibdate =      "Sat Feb 25 13:24:29 MST 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/jcomputapplmath2010.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S037704271000484X",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Computational and Applied Mathematics",
  journal-URL =  "http://www.sciencedirect.com/science/journal/03770427",
}

@Article{Bala:2011:DTD,
  author =       "Vasanth Bala and Evelyn Duesterwald and Sanjeev
                 Banerjia",
  title =        "{Dynamo}: a transparent dynamic optimization system",
  journal =      j-SIGPLAN,
  volume =       "46",
  number =       "4",
  pages =        "41--52",
  month =        apr,
  year =         "2011",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1988042.1988044",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue May 24 10:55:07 MDT 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "We describe the design and implementation of Dynamo, a
                 software dynamic optimization system that is capable of
                 transparently improving the performance of a native
                 instruction stream as it executes on the processor. The
                 input native instruction stream to Dynamo can be
                 dynamically generated (by a JIT for example), or it can
                 come from the execution of a statically compiled native
                 binary. This paper evaluates the Dynamo system in the
                 latter, more challenging situation, in order to
                 emphasize the limits, rather than the potential, of the
                 system. Our experiments demonstrate that even
                 statically optimized native binaries can be accelerated
                 Dynamo, and often by a significant degree.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Basanta-Val:2011:ECM,
  author =       "P. Basanta-Val and M. Garc{\'\i}a-Valls and I.
                 Est{\'e}vez-Ayres",
  title =        "Extending the concurrency model of the real-time
                 specification for {Java}",
  journal =      j-CCPE,
  volume =       "23",
  number =       "14",
  pages =        "1623--1645",
  day =          "25",
  month =        sep,
  year =         "2011",
  CODEN =        "CCPEBO",
  DOI =          "https://doi.org/10.1002/cpe.1675",
  ISSN =         "1532-0626 (print), 1532-0634 (electronic)",
  ISSN-L =       "1532-0626",
  bibdate =      "Mon Dec 5 10:08:59 MST 2011",
  bibsource =    "http://www.interscience.wiley.com/jpages/1532-0626;
                 https://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Concurrency and Computation: Practice and Experience",
  journal-URL =  "http://www.interscience.wiley.com/jpages/1532-0626",
  onlinedate =   "4 Nov 2010",
}

@Article{Basanta-Val:2011:FTM,
  author =       "Pablo Basanta-Val and Marisol Garc{\'\i}a-Valls and
                 Iria Est{\'e}vez-Ayres and Jorge
                 Fern{\'a}ndez-Gonz{\'a}lez",
  title =        "Fine tuning of the multiplexing facilities of {Java}'s
                 {Remote Method Invocation}",
  journal =      j-CCPE,
  volume =       "23",
  number =       "11",
  pages =        "1236--1260",
  day =          "10",
  month =        aug,
  year =         "2011",
  CODEN =        "CCPEBO",
  DOI =          "https://doi.org/10.1002/cpe.1701",
  ISSN =         "1532-0626 (print), 1532-0634 (electronic)",
  ISSN-L =       "1532-0626",
  bibdate =      "Mon Dec 5 10:08:56 MST 2011",
  bibsource =    "http://www.interscience.wiley.com/jpages/1532-0626;
                 https://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Concurrency and Computation: Practice and Experience",
  journal-URL =  "http://www.interscience.wiley.com/jpages/1532-0626",
  onlinedate =   "18 Jan 2011",
}

@Article{Basanta-Val:2011:NFI,
  author =       "P. Basanta-Val and M. Garcia-Valls and I.
                 Estevez-Ayres",
  title =        "Non-functional information transmission patterns for
                 distributed real-time {Java}",
  journal =      j-SPE,
  volume =       "41",
  number =       "12",
  pages =        "1409--1435",
  month =        "????",
  year =         "2011",
  CODEN =        "SPEXBL",
  DOI =          "https://doi.org/10.1002/spe.1084",
  ISSN =         "0038-0644 (print), 1097-024X (electronic)",
  ISSN-L =       "0038-0644",
  bibdate =      "Fri Dec 2 07:49:37 MST 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/spe.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Software --- Practice and Experience",
  journal-URL =  "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)1097-024X",
  onlinedate =   "23 May 2011",
}

@Article{Bellia:2011:PJS,
  author =       "Marco Bellia and M. Eugenia Occhiuto",
  title =        "Properties of {Java} Simple Closures",
  journal =      j-FUND-INFO,
  volume =       "109",
  number =       "3",
  pages =        "237--253",
  month =        aug,
  year =         "2011",
  CODEN =        "FUMAAJ",
  DOI =          "https://doi.org/10.3233/FI-2011-508",
  ISSN =         "0169-2968 (print), 1875-8681 (electronic)",
  ISSN-L =       "0169-2968",
  bibdate =      "Sat Mar 5 17:13:24 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/fundinfo2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Fundamenta Informaticae",
  journal-URL =  "http://content.iospress.com/journals/fundamenta-informaticae",
}

@Article{Bergenti:2011:PPS,
  author =       "F. Bergenti and L. Chiarabini and G. Rossi",
  title =        "Programming with partially specified aggregates in
                 {Java}",
  journal =      j-COMP-LANGS-SYS-STRUCT,
  volume =       "37",
  number =       "4",
  pages =        "178--192",
  month =        oct,
  year =         "2011",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1016/j.cl.2011.07.002",
  ISSN =         "1477-8424 (print), 1873-6866 (electronic)",
  ISSN-L =       "1477-8424",
  bibdate =      "Wed Apr 11 16:28:11 MDT 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/complngs.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://www.sciencedirect.com/science/journal/14778424",
  URL =          "http://www.sciencedirect.com/science/article/pii/S1477842411000169",
  acknowledgement = ack-nhfb,
  fjournal =     "Computer Languages, Systems {\&} Structures",
  journal-URL =  "http://www.sciencedirect.com/science/journal/14778424",
}

@Article{Borstler:2011:QEI,
  author =       "J{\"u}rgen B{\"o}rstler and Marie Nordstr{\"o}m and
                 James H. Paterson",
  title =        "On the Quality of Examples in Introductory {Java}
                 Textbooks",
  journal =      j-TOCE,
  volume =       "11",
  number =       "1",
  pages =        "3:1--3:??",
  month =        feb,
  year =         "2011",
  CODEN =        "????",
  ISSN =         "1946-6226",
  bibdate =      "Mon Feb 28 16:08:34 MST 2011",
  bibsource =    "http://www.acm.org/pubs/toce;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "Example programs play an important role in the
                 teaching and learning of programming. Students as well
                 as teachers rank examples as the most important
                 resources for learning to program. Example programs
                 work as role models and must therefore always be
                 consistent with the principles and rules we are
                 teaching. However, it is difficult to find or develop
                 examples that are fully faithful to all principles and
                 guidelines of the object-oriented paradigm and also
                 follow general pedagogical principles and practices.
                 Unless students are able to engage with good examples,
                 they will not be able to tell desirable from
                 undesirable properties in their own and others'
                 programs.",
  acknowledgement = ack-nhfb,
  articleno =    "3",
  fjournal =     "ACM Transactions on Computing Education",
}

@Article{Carlisle:2011:WCB,
  author =       "Martin C. Carlisle",
  title =        "Why {I} came back to {Ada}",
  journal =      j-SIGADA-LETTERS,
  volume =       "31",
  number =       "3",
  pages =        "37--38",
  month =        dec,
  year =         "2011",
  CODEN =        "AALEE5",
  DOI =          "https://doi.org/10.1145/2070336.2070354",
  ISSN =         "1094-3641 (print), 1557-9476 (electronic)",
  ISSN-L =       "1094-3641",
  bibdate =      "Fri Apr 6 11:01:24 MDT 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigada.bib",
  abstract =     "After the Air Force Academy switched its curriculum to
                 Java, I extracted myself from the Ada community and
                 moved on to other research interests, particularly
                 computer security. In this talk, I'll explain the new
                 developments that brought me back to Ada and how Ada
                 and SPARK may be a secret weapon in the 21st century.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGADA Ada Letters",
}

@Book{Cecco:2011:SJG,
  author =       "Raffaele Cecco",
  title =        "Supercharged {JavaScript} Graphics",
  publisher =    pub-ORA,
  address =      pub-ORA:adr,
  pages =        "400 (est.)",
  year =         "2011",
  ISBN =         "1-4493-9363-2",
  ISBN-13 =      "978-1-4493-9363-2",
  LCCN =         "????",
  bibdate =      "Wed Apr 27 10:01:59 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
}

@Article{Chen:2011:MJP,
  author =       "Kuo-Yi Chen and J. Morris Chang and Ting-Wei Hou",
  title =        "Multithreading in {Java}: Performance and Scalability
                 on Multicore Systems",
  journal =      j-IEEE-TRANS-COMPUT,
  volume =       "60",
  number =       "11",
  pages =        "1521--1534",
  month =        nov,
  year =         "2011",
  CODEN =        "ITCOB4",
  DOI =          "https://doi.org/10.1109/TC.2010.232",
  ISSN =         "0018-9340 (print), 1557-9956 (electronic)",
  ISSN-L =       "0018-9340",
  bibdate =      "Tue Sep 27 07:57:50 MDT 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ieeetranscomput.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://ieeexplore.ieee.org/stamp/stamp.jsp?tp=&arnumber=5661769",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE Transactions on Computers",
  journal-URL =  "http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=12",
}

@Article{Deitcher:2011:SPJ,
  author =       "Avi Deitcher",
  title =        "Simplicity and performance: {JavaScript} on the
                 server",
  journal =      j-LINUX-J,
  volume =       "2011",
  number =       "204",
  pages =        "3:1--3:??",
  month =        apr,
  year =         "2011",
  CODEN =        "LIJOFX",
  ISSN =         "1075-3583 (print), 1938-3827 (electronic)",
  ISSN-L =       "1075-3583",
  bibdate =      "Fri May 13 12:05:08 MDT 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  articleno =    "3",
  fjournal =     "Linux Journal",
  journal-URL =  "http://portal.acm.org/citation.cfm?id=J508",
}

@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:??",
  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/java2010.bib;
                 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,
  articleno =    "20",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Duarte:2011:ICS,
  author =       "Rafael Duarte and Alexandre Mota and Augusto Sampaio",
  title =        "Introducing concurrency in sequential {Java} via
                 laws",
  journal =      j-INFO-PROC-LETT,
  volume =       "111",
  number =       "3",
  pages =        "129--134",
  day =          "1",
  month =        jan,
  year =         "2011",
  CODEN =        "IFPLAT",
  ISSN =         "0020-0190 (print), 1872-6119 (electronic)",
  ISSN-L =       "0020-0190",
  bibdate =      "Thu Mar 31 12:46:53 MDT 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://www.sciencedirect.com/science/journal/00200190",
  acknowledgement = ack-nhfb,
  fjournal =     "Information Processing Letters",
  journal-URL =  "http://www.sciencedirect.com/science/journal/00200190",
}

@Article{elBoustani:2011:ITE,
  author =       "Nabil el Boustani and Jurriaan Hage",
  title =        "Improving type error messages for generic {Java}",
  journal =      j-HIGHER-ORDER-SYMB-COMPUT,
  volume =       "24",
  number =       "1--2",
  pages =        "3--39",
  month =        jun,
  year =         "2011",
  CODEN =        "LSCOEX",
  ISSN =         "1388-3690 (print), 2212-0793 (electronic)",
  ISSN-L =       "1388-3690",
  bibdate =      "Fri Oct 26 09:07:29 MDT 2012",
  bibsource =    "http://springerlink.metapress.com/openurl.asp?genre=issue&issn=1388-3690&volume=24&issue=1;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://www.springerlink.com/openurl.asp?genre=article&issn=1388-3690&volume=24&issue=1&spage=3",
  acknowledgement = ack-nhfb,
  fjournal =     "Higher-Order and Symbolic Computation",
}

@Article{Esquembre:2011:TPL,
  author =       "Francisco Esquembre",
  title =        "There Is Parallel Life for {Java} Scientific
                 Programmers!",
  journal =      j-COMPUT-SCI-ENG,
  volume =       "13",
  number =       "4",
  pages =        "6--10",
  month =        jul # "\slash " # aug,
  year =         "2011",
  CODEN =        "CSENFA",
  DOI =          "https://doi.org/10.1109/MCSE.2011.72",
  ISSN =         "1521-9615 (print), 1558-366X (electronic)",
  ISSN-L =       "1521-9615",
  bibdate =      "Fri Jul 22 06:47:06 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Computing in Science and Engineering",
  journal-URL =  "http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=5992",
}

@Article{Feldthaus:2011:TSR,
  author =       "Asger Feldthaus and Todd Millstein and Anders
                 M{\o}ller and Max Sch{\"a}fer and Frank Tip",
  title =        "Tool-supported refactoring for {JavaScript}",
  journal =      j-SIGPLAN,
  volume =       "46",
  number =       "10",
  pages =        "119--138",
  month =        oct,
  year =         "2011",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2076021.2048078",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Dec 15 07:46:53 MST 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "OOPSLA '11 conference proceedings.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Fernandes:2011:LFS,
  author =       "S{\'e}rgio Miguel Fernandes and Jo{\~a}o Cachopo",
  title =        "Lock-free and scalable multi-version software
                 transactional memory",
  journal =      j-SIGPLAN,
  volume =       "46",
  number =       "8",
  pages =        "179--188",
  month =        aug,
  year =         "2011",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2038037.1941579",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Aug 26 14:04:45 MDT 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "PPoPP '11 Conference proceedings.",
  abstract =     "Software Transactional Memory (STM) was initially
                 proposed as a lock-free mechanism for concurrency
                 control. Early implementations had efficiency
                 limitations, and soon obstruction-free proposals
                 appeared, to tackle this problem, often simplifying STM
                 implementation. Today, most of the modern and
                 top-performing STMs use blocking designs, relying on
                 locks to ensure an atomic commit operation. This
                 approach has revealed better in practice, in part due
                 to its simplicity. Yet, it may have scalability
                 problems when we move into many-core computers,
                 requiring fine-tuning and careful programming to avoid
                 contention. In this paper we present and discuss the
                 modifications we made to a lock-based multi-version STM
                 in Java, to turn it into a lock-free implementation
                 that we have tested to scale at least up to 192 cores,
                 and which provides results that compete with, and
                 sometimes exceed, some of today's top-performing
                 lock-based implementations. The new lock-free commit
                 algorithm allows write transactions to proceed in
                 parallel, by allowing them to run their validation
                 phase independently of each other, and by resorting to
                 helping from threads that would otherwise be waiting to
                 commit, during the write-back phase. We also present a
                 new garbage collection algorithm to dispose of old
                 unused object versions that allows for asynchronous
                 identification of unnecessary versions, which minimizes
                 its interference with the rest of the transactional
                 system.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Book{Fogus:2011:JC,
  author =       "Michael Fogus and Chris Houser",
  title =        "The joy of {Clojure}",
  publisher =    pub-MANNING,
  address =      pub-MANNING:adr,
  pages =        "xxxi + 328",
  year =         "2011",
  ISBN =         "1-935182-64-1 (paperback)",
  ISBN-13 =      "978-1-935182-64-1 (paperback)",
  LCCN =         "QA76.62 .F64 2011",
  bibdate =      "Fri Nov 23 10:33:38 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/common-lisp.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 z3950.loc.gov:7090/Voyager",
  abstract =     "Provides information on the features and functions of
                 Clojure and describes how to create applications.",
  acknowledgement = ack-nhfb,
  subject =      "Clojure (Computer program language); Java (Computer
                 program language); Functional programming (Computer
                 science); Programming languages (Electronic computers);
                 Computer programming",
}

@Article{Frantzeskou:2011:SUD,
  author =       "Georgia Frantzeskou and Stephen G. MacDonell and
                 Efstathios Stamatatos and Stelios Georgiou and Stefanos
                 Gritzalis",
  title =        "The significance of user-defined identifiers in {Java}
                 source code authorship identification",
  journal =      j-INT-J-COMPUT-SYST-SCI-ENG,
  volume =       "26",
  number =       "2",
  pages =        "??--??",
  month =        mar,
  year =         "2011",
  CODEN =        "CSSEEI",
  ISSN =         "0267-6192",
  ISSN-L =       "0267-6192",
  bibdate =      "Tue Dec 3 12:04:33 MST 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/computsystscieng.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "International Journal of Computer Systems Science and
                 Engineering",
}

@Article{Gampe:2011:SMB,
  author =       "Andreas Gampe and Jeffery von Ronne and David
                 Niedzielski and Jonathan Vasek and Kleanthis Psarris",
  title =        "Safe, multiphase bounds check elimination in {Java}",
  journal =      j-SPE,
  volume =       "41",
  number =       "7",
  pages =        "753--788",
  month =        jun,
  year =         "2011",
  CODEN =        "SPEXBL",
  DOI =          "https://doi.org/10.1002/spe.1028",
  ISSN =         "0038-0644 (print), 1097-024X (electronic)",
  ISSN-L =       "0038-0644",
  bibdate =      "Tue Jun 21 17:09:57 MDT 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Software---Practice and Experience",
  journal-URL =  "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)1097-024X",
  onlinedate =   "25 Nov 2010",
}

@Article{Garbervetsky:2011:QDM,
  author =       "Diego Garbervetsky and Sergio Yovine and V{\'\i}ctor
                 Braberman and Mart{\'\i}n Rouaux and Alejandro
                 Taboada",
  title =        "Quantitative dynamic-memory analysis for {Java}",
  journal =      j-CCPE,
  volume =       "23",
  number =       "14",
  pages =        "1665--1678",
  day =          "25",
  month =        sep,
  year =         "2011",
  CODEN =        "CCPEBO",
  DOI =          "https://doi.org/10.1002/cpe.1656",
  ISSN =         "1532-0626 (print), 1532-0634 (electronic)",
  ISSN-L =       "1532-0626",
  bibdate =      "Mon Dec 5 10:08:59 MST 2011",
  bibsource =    "http://www.interscience.wiley.com/jpages/1532-0626;
                 https://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Concurrency and Computation: Practice and Experience",
  journal-URL =  "http://www.interscience.wiley.com/jpages/1532-0626",
  onlinedate =   "4 Nov 2010",
}

@Article{Giacaman:2011:OOP,
  author =       "Nasser Giacaman and Oliver Sinnen",
  title =        "Object-Oriented Parallelisation of {Java} Desktop
                 Programs",
  journal =      j-IEEE-SOFTWARE,
  volume =       "28",
  number =       "1",
  pages =        "32--38",
  month =        jan # "\slash " # feb,
  year =         "2011",
  CODEN =        "IESOEG",
  DOI =          "https://doi.org/10.1109/MS.2010.135",
  ISSN =         "0740-7459 (print), 0740-7459 (electronic)",
  ISSN-L =       "0740-7459",
  bibdate =      "Thu Dec 23 16:29:15 2010",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE Software",
  journal-URL =  "http://www.computer.org/portal/web/csdl/magazines/software",
}

@Article{Gidra:2011:ASG,
  author =       "Lokesh Gidra and Ga{\"e}l Thomas and Julien Sopena and
                 Marc Shapiro",
  title =        "Assessing the scalability of garbage collectors on
                 many cores",
  journal =      j-OPER-SYS-REV,
  volume =       "5",
  number =       "3",
  pages =        "15--19",
  month =        dec,
  year =         "2011",
  CODEN =        "OSRED8",
  DOI =          "https://doi.org/10.1145/2094091.2094096",
  ISSN =         "0163-5980 (print), 1943-586X (electronic)",
  ISSN-L =       "0163-5980",
  bibdate =      "Mon Jan 16 19:01:36 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/opersysrev.bib",
  abstract =     "Managed Runtime Environments (MRE) are increasingly
                 used for application servers that use large multi-core
                 hardware. We find that the garbage collector is
                 critical for overall performance in this setting. We
                 explore the costs and scalability of the garbage
                 collectors on a contemporary 48-core multiprocessor
                 machine. We present experimental evaluation of the
                 parallel and concurrent garbage collectors present in
                 OpenJDK, a widely-used Java virtual machine. We show
                 that garbage collection represents a substantial amount
                 of an application's execution time, and does not scale
                 well as the number of cores increases. We attempt to
                 identify some critical scalability bottlenecks for
                 garbage collectors.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGOPS Operating Systems Review",
}

@Article{Gong:2011:JSA,
  author =       "Li Gong",
  title =        "{Java} security architecture revisited",
  journal =      j-CACM,
  volume =       "54",
  number =       "11",
  pages =        "48--52",
  month =        nov,
  year =         "2011",
  CODEN =        "CACMA2",
  DOI =          "https://doi.org/10.1145/2018396.2018411",
  ISSN =         "0001-0782 (print), 1557-7317 (electronic)",
  ISSN-L =       "0001-0782",
  bibdate =      "Sun Nov 6 06:54:03 MST 2011",
  bibsource =    "http://www.acm.org/pubs/contents/journals/cacm/;
                 https://www.math.utah.edu/pub/tex/bib/cacm2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Communications of the ACM",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J79",
}

@Article{Grech:2011:JGE,
  author =       "Neville Grech and Julian Rathke and Bernd Fischer",
  title =        "{JEqualityGen}: generating equality and hashing
                 methods",
  journal =      j-SIGPLAN,
  volume =       "46",
  number =       "2",
  pages =        "177--186",
  month =        feb,
  year =         "2011",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1942788.1868320",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Feb 14 16:37:34 MST 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "Manually implementing equals (for object comparisons)
                 and hashCode (for object hashing) methods in large
                 software projects is tedious and error-prone. This is
                 due to many special cases, such as field shadowing,
                 comparison between different types, or cyclic object
                 graphs. Here, we present JEqualityGen, a source code
                 generator that automatically derives implementations of
                 these methods. JEqualityGen proceeds in two states: it
                 first uses source code reflection in MetaAspectJ to
                 generate aspects that contain the method
                 implementations, before it uses weaving on the bytecode
                 level to insert these into the target application.
                 JEqualityGen generates not only correct, but efficient
                 source code that on a typical large-scale Java
                 application exhibits a performance improvement of more
                 than two orders of magnitude in the equality operations
                 generated, compared to an existing system based on
                 runtime reflection.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Haubl:2011:ECE,
  author =       "Christian H{\"a}ubl and Christian Wimmer and Hanspeter
                 M{\"o}ssenb{\"o}ck",
  title =        "Erratum to {``Compact and Efficient Strings for Java''
                 [Science of Computer Programming {\bf 75} (2010)
                 1077--1094]}",
  journal =      j-SCI-COMPUT-PROGRAM,
  volume =       "76",
  number =       "11",
  pages =        "1073--1073",
  day =          "1",
  month =        nov,
  year =         "2011",
  CODEN =        "SCPGD4",
  ISSN =         "0167-6423 (print), 1872-7964 (electronic)",
  ISSN-L =       "0167-6423",
  bibdate =      "Tue Jun 21 10:31:56 MDT 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://www.sciencedirect.com/science/journal/01676423",
  acknowledgement = ack-nhfb,
  fjournal =     "Science of Computer Programming",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01676423",
}

@Book{Haverbeke:2011:EJM,
  author =       "Marijn Haverbeke",
  title =        "Eloquent {JavaScript}: a modern introduction to
                 programming",
  publisher =    pub-NO-STARCH,
  address =      pub-NO-STARCH:adr,
  pages =        "xiv + 205",
  year =         "2011",
  ISBN =         "1-59327-282-0",
  ISBN-13 =      "978-1-59327-282-1",
  LCCN =         "QA76.73.J39 HAV 2011; QA76.73.J39 H38 2009",
  bibdate =      "Wed Apr 27 11:18:12 MDT 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 library.ox.ac.uk:210/ADVANCE",
  URL =          "http://www.loc.gov/catdir/enhancements/fy1012/2010032246-b.html;
                 http://www.loc.gov/catdir/enhancements/fy1012/2010032246-d.html;
                 http://www.loc.gov/catdir/enhancements/fy1107/2010032246-t.html",
  acknowledgement = ack-nhfb,
  subject =      "JavaScript (Computer program language)",
}

@Article{Hofmann:2011:EOS,
  author =       "Owen S. Hofmann and Alan M. Dunn and Sangman Kim and
                 Indrajit Roy and Emmett Witchel",
  title =        "Ensuring operating system kernel integrity with
                 {OSck}",
  journal =      j-SIGPLAN,
  volume =       "46",
  number =       "3",
  pages =        "279--290",
  month =        mar,
  year =         "2011",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1961296.1950398",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue May 24 10:55:08 MDT 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "ASPLOS '11 conference proceedings",
}

@Article{Horspool:2011:PPP,
  author =       "R. Nigel Horspool and Ralf Gitzel and Giacomo Cabri
                 and Markus Aleksy",
  title =        "Principles and Practice of Programming in {Java
                 2008}---Special issue",
  journal =      j-SCI-COMPUT-PROGRAM,
  volume =       "76",
  number =       "11",
  pages =        "969--969",
  day =          "1",
  month =        nov,
  year =         "2011",
  CODEN =        "SCPGD4",
  ISSN =         "0167-6423 (print), 1872-7964 (electronic)",
  ISSN-L =       "0167-6423",
  bibdate =      "Tue Jun 21 10:31:56 MDT 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://www.sciencedirect.com/science/journal/01676423",
  acknowledgement = ack-nhfb,
  fjournal =     "Science of Computer Programming",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01676423",
}

@Book{Horstmann:2011:CJA,
  author =       "Cay S. Horstmann",
  title =        "Core {Java}: Advanced Topics",
  volume =       "2",
  publisher =    pub-PH,
  address =      pub-PH:adr,
  edition =      "Nineth",
  pages =        "1088 (est.)",
  year =         "2011",
  ISBN =         "0-13-708160-X",
  ISBN-13 =      "978-0-13-708160-8",
  LCCN =         "????",
  bibdate =      "Mon Jan 28 14:57:29 MST 2013",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  xxaddress =    pub-PEARSON-EDUCATION:adr,
  xxpublisher =  pub-PEARSON-EDUCATION,
}

@Article{Huang:2011:SBA,
  author =       "Gang Huang and Weihu Wang and Tiancheng Liu and Hong
                 Mei",
  title =        "Simulation-based analysis of middleware service impact
                 on system reliability: {Experiment} on {Java}
                 application server",
  journal =      j-J-SYST-SOFTW,
  volume =       "84",
  number =       "7",
  pages =        "1160--1170",
  month =        jul,
  year =         "2011",
  CODEN =        "JSSODM",
  ISSN =         "0164-1212 (print), 1873-1228 (electronic)",
  ISSN-L =       "0164-1212",
  bibdate =      "Tue Jun 21 10:22:31 MDT 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://www.sciencedirect.com/science/journal/01641212",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Systems and Software",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01641212",
}

@Book{Hughes-Croucher:2011:NRS,
  author =       "Tom Hughes-Croucher",
  title =        "Node: Up and Running: Scalable Server-Side Code with
                 {JavaScript}",
  publisher =    pub-ORA,
  address =      pub-ORA:adr,
  pages =        "????",
  year =         "2011",
  ISBN =         "1-4493-9858-8",
  ISBN-13 =      "978-1-4493-9858-3",
  LCCN =         "????",
  bibdate =      "Wed Apr 27 10:01:59 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
}

@Article{Jenista:2011:OSO,
  author =       "James Christopher Jenista and Yong hun Eom and Brian
                 Charles Demsky",
  title =        "{OoOJava}: software out-of-order execution",
  journal =      j-SIGPLAN,
  volume =       "46",
  number =       "8",
  pages =        "57--68",
  month =        aug,
  year =         "2011",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2038037.1941563",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Aug 26 14:04:45 MDT 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "PPoPP '11 Conference proceedings.",
  abstract =     "Developing parallel software using current tools can
                 be challenging. Even experts find it difficult to
                 reason about the use of locks and often accidentally
                 introduce race conditions and deadlocks into parallel
                 software. OoOJava is a compiler-assisted approach that
                 leverages developer annotations along with static
                 analysis to provide an easy-to-use deterministic
                 parallel programming model. OoOJava extends Java with a
                 task annotation that instructs the compiler to consider
                 a code block for out-of-order execution. OoOJava
                 executes tasks as soon as their data dependences are
                 resolved and guarantees that the execution of an
                 annotated program preserves the exact semantics of the
                 original sequential program. We have implemented
                 OoOJava and achieved an average speedup of 16.6x on our
                 ten benchmarks.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Jeyalatha:2011:DIT,
  author =       "S. Jeyalatha and B. Vijayakumar and Munawwar Firoz",
  title =        "Design and Implementation of a Tool for {Web} Data
                 Extraction and Storage using {Java} and Uniform
                 Interface",
  journal =      j-INT-J-COMP-APPL,
  volume =       "22",
  number =       "??",
  pages =        "1--6",
  month =        may,
  year =         "2011",
  CODEN =        "????",
  DOI =          "https://doi.org/10.5120/2575-3551",
  ISSN =         "0975-8887",
  ISSN-L =       "0975-8887",
  bibdate =      "Fri Jan 24 08:37:11 MST 2025",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/intjcompappl.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "https://www.ijcaonline.org/archives/volume22/number4/2575-3551/",
  acknowledgement = ack-nhfb,
  ajournal =     "Intern. J. of Computer Applications",
  articleno =    "4",
  fjournal =     "International Journal of Computer Applications",
  journal-URL =  "https://www.ijcaonline.org/",
}

@Article{Johari:2011:ESE,
  author =       "Kalpana Johari and Arvinder Kaur",
  title =        "Effect of software evolution on software metrics: an
                 open source case study",
  journal =      j-SIGSOFT,
  volume =       "36",
  number =       "5",
  pages =        "1--8",
  month =        sep,
  year =         "2011",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/2020976.2020987",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:16:04 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/gnu.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  abstract =     "Software needs to evolve in order to be used for a
                 longer period. The changes corresponding to corrective,
                 preventive, adaptive and perfective maintenance leads
                 to software evolution. In this paper we are presenting
                 the results of study conducted on 13 versions of JHot
                 Draw and 16 versions of Rhino released over the period
                 of 10 years. We measured Object Oriented Metrics and
                 studied the changes in the measured values over
                 different releases of two medium sized software
                 developed using Java. We also investigated the
                 applicability of Lehman's Law of Software Evolution on
                 Object Oriented Software Systems using different
                 measures. We found that Lehman's laws related with
                 increasing complexity and continuous growth are
                 supported by the data and computed metrics measure.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Jovic:2011:LLP,
  author =       "Milan Jovic and Matthias Hauswirth",
  title =        "Listener latency profiling: {Measuring} the
                 perceptible performance of interactive {Java}
                 applications",
  journal =      j-SCI-COMPUT-PROGRAM,
  volume =       "76",
  number =       "11",
  pages =        "1054--1072",
  day =          "1",
  month =        nov,
  year =         "2011",
  CODEN =        "SCPGD4",
  ISSN =         "0167-6423 (print), 1872-7964 (electronic)",
  ISSN-L =       "0167-6423",
  bibdate =      "Tue Jun 21 10:31:56 MDT 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://www.sciencedirect.com/science/journal/01676423",
  acknowledgement = ack-nhfb,
  fjournal =     "Science of Computer Programming",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01676423",
}

@Article{Kabanov:2011:DSF,
  author =       "Jevgeni Kabanov and Michael Hunger and Rein
                 Raudj{\"a}rv",
  title =        "On designing safe and flexible embedded {DSLs} with
                 {Java 5}",
  journal =      j-SCI-COMPUT-PROGRAM,
  volume =       "76",
  number =       "11",
  pages =        "970--991",
  day =          "1",
  month =        nov,
  year =         "2011",
  CODEN =        "SCPGD4",
  ISSN =         "0167-6423 (print), 1872-7964 (electronic)",
  ISSN-L =       "0167-6423",
  bibdate =      "Tue Jun 21 10:31:56 MDT 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://www.sciencedirect.com/science/journal/01676423",
  acknowledgement = ack-nhfb,
  fjournal =     "Science of Computer Programming",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01676423",
}

@Article{Kalibera:2011:FRT,
  author =       "Tomas Kalibera and Jeff Hagelberg and Petr Maj and
                 Filip Pizlo and Ben Titzer and Jan Vitek",
  title =        "A family of real-time {Java} benchmarks",
  journal =      j-CCPE,
  volume =       "23",
  number =       "14",
  pages =        "1679--1700",
  day =          "25",
  month =        sep,
  year =         "2011",
  CODEN =        "CCPEBO",
  DOI =          "https://doi.org/10.1002/cpe.1677",
  ISSN =         "1532-0626 (print), 1532-0634 (electronic)",
  ISSN-L =       "1532-0626",
  bibdate =      "Mon Dec 5 10:08:59 MST 2011",
  bibsource =    "http://www.interscience.wiley.com/jpages/1532-0626;
                 https://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Concurrency and Computation: Practice and Experience",
  journal-URL =  "http://www.interscience.wiley.com/jpages/1532-0626",
  onlinedate =   "4 Nov 2010",
}

@Article{Kalibera:2011:SRT,
  author =       "Tomas Kalibera and Filip Pizlo and Antony L. Hosking
                 and Jan Vitek",
  title =        "Scheduling real-time garbage collection on
                 uniprocessors",
  journal =      j-TOCS,
  volume =       "29",
  number =       "3",
  pages =        "8:1--8:??",
  month =        aug,
  year =         "2011",
  CODEN =        "ACSYEC",
  DOI =          "https://doi.org/10.1145/2003690.2003692",
  ISSN =         "0734-2071 (print), 1557-7333 (electronic)",
  ISSN-L =       "0734-2071",
  bibdate =      "Wed Aug 24 18:08:12 MDT 2011",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tocs/;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "Managed languages such as Java and C\# are
                 increasingly being considered for hard real-time
                 applications because of their productivity and software
                 engineering advantages. Automatic memory management, or
                 garbage collection, is a key enabler for robust,
                 reusable libraries, yet remains a challenge for
                 analysis and implementation of real-time execution
                 environments. This article comprehensively compares
                 leading approaches to hard real-time garbage
                 collection. There are many design decisions involved in
                 selecting a real-time garbage collection algorithm. For
                 time-based garbage collectors on uniprocessors one must
                 choose whether to use periodic, slack-based or hybrid
                 scheduling. A significant impediment to valid
                 experimental comparison of such choices is that
                 commercial implementations use completely different
                 proprietary infrastructures.",
  acknowledgement = ack-nhfb,
  articleno =    "8",
  fjournal =     "ACM Transactions on Computer Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J774",
}

@Article{Kim:2011:MAE,
  author =       "Minseong Kim and Andy Wellings",
  title =        "Multiprocessors and Asynchronous Event Handling in the
                 Real-Time Specification for {Java}",
  journal =      j-COMP-J,
  volume =       "54",
  number =       "8",
  pages =        "1308--1324",
  month =        aug,
  year =         "2011",
  CODEN =        "CMPJA6",
  DOI =          "https://doi.org/10.1093/comjnl/bxr030",
  ISSN =         "0010-4620 (print), 1460-2067 (electronic)",
  ISSN-L =       "0010-4620",
  bibdate =      "Wed Aug 17 16:34:11 MDT 2011",
  bibsource =    "http://comjnl.oxfordjournals.org/content/54/8.toc;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://comjnl.oxfordjournals.org/content/54/8/1308.full.pdf+html",
  acknowledgement = ack-nhfb,
  fjournal =     "Computer Journal",
  journal-URL =  "http://comjnl.oxfordjournals.org/",
  onlinedate =   "March 26, 2011",
}

@Article{Krieger:2011:AES,
  author =       "Matthias P. Krieger and Alexander Knapp and Burkhart
                 Wolff",
  title =        "Automatic and efficient simulation of operation
                 contracts",
  journal =      j-SIGPLAN,
  volume =       "46",
  number =       "2",
  pages =        "53--62",
  month =        feb,
  year =         "2011",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1942788.1868303",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Feb 14 16:37:34 MST 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "Operation contracts consisting of pre- and
                 postconditions are a well-known means of specifying
                 operations. In this paper we deal with the problem of
                 operation contract simulation, i.e., determining
                 operation results satisfying the postconditions based
                 on input data supplied by the user; simulating
                 operation contracts is an important technique for
                 requirements validation and prototyping. Current
                 approaches to operation contract simulation exhibit
                 poor performance for large sets of input data or
                 require additional guidance from the user. We show how
                 these problems can be alleviated and describe an
                 efficient as well as fully automatic approach. It is
                 implemented in our tool OCLexec that generates from
                 UML/OCL operation contracts corresponding Java
                 implementations which call a constraint solver at
                 runtime.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Kuehnhausen:2011:AJM,
  author =       "Martin Kuehnhausen and Victor S. Frost",
  title =        "Application of the {Java Message Service} in mobile
                 monitoring environments",
  journal =      j-J-NETW-COMPUT-APPL,
  volume =       "34",
  number =       "5",
  pages =        "1707--1716",
  month =        sep,
  year =         "2011",
  CODEN =        "JNCAF3",
  ISSN =         "1084-8045 (print), 1095-8592 (electronic)",
  ISSN-L =       "1084-8045",
  bibdate =      "Wed Jan 28 15:44:03 MST 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/jnetwcomputappl.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S1084804511001159",
  acknowledgement = ack-nhfb,
  ajournal =     "J. Netw. Comput. Appl.",
  fjournal =     "Journal of Network and Computer Applications",
  journal-URL =  "http://www.sciencedirect.com/science/journal/10848045",
}

@Article{Kumari:2011:AOO,
  author =       "Usha Kumari and Sucheta Bhasin",
  title =        "Application of Object-Oriented Metrics To {C++} and
                 {Java}: a Comparative Study",
  journal =      j-SIGSOFT,
  volume =       "36",
  number =       "2",
  pages =        "1--10",
  month =        mar,
  year =         "2011",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/1943371.1943386",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:16:00 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  abstract =     "The increasing importance of software measurement has
                 led to design and development of new software measures.
                 As the development of object-oriented software is
                 rising, more and more metrics are being defined for
                 object-oriented programming languages. But there is a
                 little understanding of comparative application of many
                 of these measures to different programming languages.
                 As a consequence, it is very difficult for software
                 managers and developers to select suitable measures and
                 programming languages for object-oriented systems. In
                 this paper, we investigate 23 object-oriented metrics
                 proposed by various researchers. The metrics are
                 applied to same set of 15 programs coded in C++ and
                 Java in an attempt to make comparative study of these
                 two prominent object-oriented programming languages.
                 The work done here reveals that these object-oriented
                 metrics can be applied successfully to both Java and
                 C++. But, Java proves to be more object-oriented than
                 C++ as per intuition. However, counting rules defined
                 for computation of these metrics should be framed more
                 carefully.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Li:2011:JEC,
  author =       "Siliang Li and Gang Tan",
  title =        "{JET}: exception checking in the {Java Native
                 Interface}",
  journal =      j-SIGPLAN,
  volume =       "46",
  number =       "10",
  pages =        "345--358",
  month =        oct,
  year =         "2011",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2076021.2048095",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Dec 15 07:46:53 MST 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "OOPSLA '11 conference proceedings.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Lux:2011:TSD,
  author =       "Alexander Lux and Artem Starostin",
  title =        "A tool for static detection of timing channels in
                 {Java}",
  journal =      j-J-CRYPTO-ENG,
  volume =       "1",
  number =       "4",
  pages =        "303--313",
  month =        dec,
  year =         "2011",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1007/s13389-011-0021-z",
  ISSN =         "2190-8508 (print), 2190-8516 (electronic)",
  ISSN-L =       "2190-8508",
  bibdate =      "Wed Aug 20 18:51:32 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/jcryptoeng.bib",
  URL =          "http://link.springer.com/article/10.1007/s13389-011-0021-z",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Cryptographic Engineering",
  journal-URL =  "http://link.springer.com/journal/13389",
}

@Article{Martinez-Llario:2011:DJS,
  author =       "J. Martinez-Llario and M. Gonzalez-Alcaide",
  title =        "Design of a {Java} spatial extension for relational
                 databases",
  journal =      j-J-SYST-SOFTW,
  volume =       "84",
  number =       "12",
  pages =        "2314--2323",
  month =        dec,
  year =         "2011",
  CODEN =        "JSSODM",
  DOI =          "https://doi.org/10.1016/j.jss.2011.06.072",
  ISSN =         "0164-1212 (print), 1873-1228 (electronic)",
  ISSN-L =       "0164-1212",
  bibdate =      "Mon Feb 6 15:39:27 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/jsystsoftw.bib;
                 http://www.sciencedirect.com/science/journal/01641212",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0164121211001695",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Systems and Software",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01641212",
}

@Article{McMillan:2011:SVM,
  author =       "William W. McMillan",
  title =        "The soul of the virtual machine",
  journal =      j-IEEE-SPECTRUM,
  volume =       "48",
  number =       "7",
  pages =        "44--59",
  month =        jul,
  year =         "2011",
  CODEN =        "IEESAM",
  DOI =          "https://doi.org/10.1109/MSPEC.2011.5910448",
  ISSN =         "0018-9235 (print), 1939-9340 (electronic)",
  ISSN-L =       "0018-9235",
  bibdate =      "Fri Jan 17 18:54:05 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ieeespectrum2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE Spectrum",
  journal-URL =  "http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=6",
  keywords =     "Ersatz machine code; Java; Java compiler; Java virtual
                 machines; Operating systems; program compilers; Program
                 processors; Programming; virtual machines; Virtual
                 machining; Virtual prototyping",
}

@Article{Palmer:2011:BJM,
  author =       "Zachary Palmer and Scott F. Smith",
  title =        "Backstage {Java}: making a difference in
                 metaprogramming",
  journal =      j-SIGPLAN,
  volume =       "46",
  number =       "10",
  pages =        "939--958",
  month =        oct,
  year =         "2011",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2076021.2048137",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Dec 15 07:46:53 MST 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "OOPSLA '11 conference proceedings.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Papadimitriou:2011:SES,
  author =       "Stergios Papadimitriou and Konstantinos Terzidis and
                 Seferina Mavroudi and Spiridon Likothanassis",
  title =        "{ScalaLab}: An Effective {Scala}-Based Scientific
                 Programming Environment for {Java}",
  journal =      j-COMPUT-SCI-ENG,
  volume =       "13",
  number =       "5",
  pages =        "43--55",
  month =        sep # "\slash " # oct,
  year =         "2011",
  CODEN =        "CSENFA",
  DOI =          "https://doi.org/10.1109/MCSE.2010.77",
  ISSN =         "1521-9615 (print), 1558-366X (electronic)",
  ISSN-L =       "1521-9615",
  bibdate =      "Wed Aug 31 18:09:32 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Computing in Science and Engineering",
  journal-URL =  "http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=5992",
}

@Article{Park:2011:DCM,
  author =       "Heewan Park and Hyun-il Lim and Seokwoo Choi and
                 Taisook Han",
  title =        "Detecting Common Modules in {Java} Packages Based on
                 Static Object Trace Birthmark",
  journal =      j-COMP-J,
  volume =       "54",
  number =       "1",
  pages =        "108--124",
  month =        jan,
  year =         "2011",
  CODEN =        "CMPJA6",
  DOI =          "https://doi.org/10.1093/comjnl/bxp095",
  ISSN =         "0010-4620 (print), 1460-2067 (electronic)",
  ISSN-L =       "0010-4620",
  bibdate =      "Tue Dec 21 19:26:47 MST 2010",
  bibsource =    "http://comjnl.oxfordjournals.org/content/54/1.toc;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://comjnl.oxfordjournals.org/content/54/1/108.full.pdf+html",
  acknowledgement = ack-nhfb,
  fjournal =     "Computer Journal",
  journal-URL =  "http://comjnl.oxfordjournals.org/",
  onlinedate =   "November 5, 2009",
}

@Article{Parker:2011:DPG,
  author =       "Jon Parker and Joshua M. Epstein",
  title =        "A Distributed Platform for Global-Scale Agent-Based
                 Models of Disease Transmission",
  journal =      j-TOMACS,
  volume =       "22",
  number =       "1",
  pages =        "2:1--2:??",
  month =        dec,
  year =         "2011",
  CODEN =        "ATMCEZ",
  DOI =          "https://doi.org/10.1145/2043635.2043637",
  ISSN =         "1049-3301 (print), 1558-1195 (electronic)",
  ISSN-L =       "1049-3301",
  bibdate =      "Tue Dec 20 17:48:00 MST 2011",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tomacs/;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/tomacs.bib",
  abstract =     "The Global-Scale Agent Model (GSAM) is presented. The
                 GSAM is a high-performance distributed platform for
                 agent-based epidemic modeling capable of simulating a
                 disease outbreak in a population of several billion
                 agents. It is unprecedented in its scale, its speed,
                 and its use of Java. Solutions to multiple challenges
                 inherent in distributing massive agent-based models are
                 presented. Communication, synchronization, and memory
                 usage are among the topics covered in detail. The
                 memory usage discussion is Java specific. However, the
                 communication and synchronization discussions apply
                 broadly. We provide benchmarks illustrating the GSAM's
                 speed and scalability.",
  acknowledgement = ack-nhfb,
  articleno =    "2",
  fjournal =     "ACM Transactions on Modeling and Computer Simulation",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?&idx=J781",
}

@Article{Pour:2011:MBD,
  author =       "Niusha Hakimi Pour and Paul Strooper and Andy
                 Wellings",
  title =        "A model-based development approach for the
                 verification of real-time {Java} code",
  journal =      j-CCPE,
  volume =       "23",
  number =       "13",
  pages =        "1583--1606",
  day =          "10",
  month =        sep,
  year =         "2011",
  CODEN =        "CCPEBO",
  DOI =          "https://doi.org/10.1002/cpe.1728",
  ISSN =         "1532-0626 (print), 1532-0634 (electronic)",
  ISSN-L =       "1532-0626",
  bibdate =      "Mon Dec 5 10:08:58 MST 2011",
  bibsource =    "http://www.interscience.wiley.com/jpages/1532-0626;
                 https://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Concurrency and Computation: Practice and Experience",
  journal-URL =  "http://www.interscience.wiley.com/jpages/1532-0626",
  onlinedate =   "24 Apr 2011",
}

@Article{Ricci:2011:SAO,
  author =       "Alessandro Ricci and Mirko Viroli and Giulio
                 Piancastelli",
  title =        "{simpA}: an agent-oriented approach for programming
                 concurrent applications on top of {Java}",
  journal =      j-SCI-COMPUT-PROGRAM,
  volume =       "76",
  number =       "1",
  pages =        "37--62",
  day =          "1",
  month =        jan,
  year =         "2011",
  CODEN =        "SCPGD4",
  ISSN =         "0167-6423 (print), 1872-7964 (electronic)",
  ISSN-L =       "0167-6423",
  bibdate =      "Fri Apr 1 18:39:40 MDT 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://www.sciencedirect.com/science/journal/01676423",
  acknowledgement = ack-nhfb,
  fjournal =     "Science of Computer Programming",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01676423",
}

@Article{Richards:2011:ACJ,
  author =       "Gregor Richards and Andreas Gal and Brendan Eich and
                 Jan Vitek",
  title =        "Automated construction of {JavaScript} benchmarks",
  journal =      j-SIGPLAN,
  volume =       "46",
  number =       "10",
  pages =        "677--694",
  month =        oct,
  year =         "2011",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2076021.2048119",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Dec 15 07:46:53 MST 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "OOPSLA '11 conference proceedings.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Schoeberl:2011:HAL,
  author =       "Martin Schoeberl and Stephan Korsholm and Tomas
                 Kalibera and Anders P. Ravn",
  title =        "A Hardware Abstraction Layer in {Java}",
  journal =      j-TECS,
  volume =       "10",
  number =       "4",
  pages =        "42:1--42:??",
  month =        nov,
  year =         "2011",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/2043662.2043666",
  ISSN =         "1539-9087 (print), 1558-3465 (electronic)",
  ISSN-L =       "1539-9087",
  bibdate =      "Mon Dec 19 15:49:06 MST 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/tecs.bib",
  abstract =     "Embedded systems use specialized hardware devices to
                 interact with their environment, and since they have to
                 be dependable, it is attractive to use a modern,
                 type-safe programming language like Java to develop
                 programs for them. Standard Java, as a
                 platform-independent language, delegates access to
                 devices, direct memory access, and interrupt handling
                 to some underlying operating system or kernel, but in
                 the embedded systems domain resources are scarce and a
                 Java Virtual Machine (JVM) without an underlying
                 middleware is an attractive architecture. The
                 contribution of this article is a proposal for Java
                 packages with hardware objects and interrupt handlers
                 that interface to such a JVM.",
  acknowledgement = ack-nhfb,
  articleno =    "42",
  fjournal =     "ACM Transactions on Embedded Computing Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?&idx=J840",
}

@Article{Sewe:2011:CCS,
  author =       "Andreas Sewe and Mira Mezini and Aibek Sarimbekov and
                 Walter Binder",
  title =        "Da capo con {Scala}: design and analysis of a {Scala}
                 benchmark suite for the {Java Virtual Machine}",
  journal =      j-SIGPLAN,
  volume =       "46",
  number =       "10",
  pages =        "657--676",
  month =        oct,
  year =         "2011",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2076021.2048118",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Dec 15 07:46:53 MST 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "OOPSLA '11 conference proceedings.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Siegel:2011:AFV,
  author =       "Stephen F. Siegel and Timothy K. Zirkel",
  title =        "Automatic formal verification of {MPI}-based parallel
                 programs",
  journal =      j-SIGPLAN,
  volume =       "46",
  number =       "8",
  pages =        "309--310",
  month =        aug,
  year =         "2011",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2038037.1941603",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Aug 26 14:04:45 MDT 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/pvm.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "PPoPP '11 Conference proceedings.",
  abstract =     "The Toolkit for Accurate Scientific Software (TASS) is
                 a suite of tools for the formal verification of
                 MPI-based parallel programs used in computational
                 science. TASS can verify various safety properties as
                 well as compare two programs for functional
                 equivalence. The TASS front end takes an integer $ n
                 \geq 1 $ and a C/MPI program, and constructs an
                 abstract model of the program with $n$ processes.
                 Procedures, structs, (multi-dimensional) arrays,
                 heap-allocated data, pointers, and pointer arithmetic
                 are all representable in a TASS model. The model is
                 then explored using symbolic execution and explicit
                 state space enumeration. A number of techniques are
                 used to reduce the time and memory consumed. A variety
                 of realistic MPI programs have been verified with TASS,
                 including Jacobi iteration and manager-worker type
                 programs, and some subtle defects have been discovered.
                 TASS is written in Java and is available from
                 \path=http://vsl.cis.udel.edu/tass= under the Gnu
                 Public License.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Singer:2011:GCA,
  author =       "Jeremy Singer and George Kovoor and Gavin Brown and
                 Mikel Luj{\'a}n",
  title =        "Garbage collection auto-tuning for {Java MapReduce} on
                 multi-cores",
  journal =      j-SIGPLAN,
  volume =       "46",
  number =       "11",
  pages =        "109--118",
  month =        nov,
  year =         "2011",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2076022.1993495",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Dec 15 07:46:57 MST 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "ISMM '11 conference proceedings.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Book{Subramaniam:2011:PCJ,
  author =       "Venkat Subramaniam",
  title =        "Programming concurrency on the {JVM}: mastering
                 synchronization, {STM}, and actors",
  publisher =    "Pragmatic Bookshelf",
  address =      "Dallas, TX",
  pages =        "xvii + 270",
  year =         "2011",
  ISBN =         "1-934356-76-X",
  ISBN-13 =      "978-1-934356-76-0",
  LCCN =         "QA76.73.J38 S8467 2011",
  bibdate =      "Thu Dec 4 08:35:54 MST 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib;
                 z3950.loc.gov:7090/Voyager",
  series =       "The pragmatic programmers",
  abstract =     "Stop dreading concurrency and start reaping the pure
                 power of modern multicore hardware. Learn how to avoid
                 shared mutable state and how to write safe, elegant,
                 explicit synchronization-free programs in Java or other
                 JVM languages, including Clojure, JRuby, Groovy, or
                 Scala. This book is the first to show you the three
                 prominent concurrency styles: the synchronization model
                 of the JDK, Software Transactional Memory (STM), and
                 actor-based concurrency. You'll learn the benefits of
                 each of these models, when and how to use them, and
                 what their limitations are so you can compare and
                 choose what works best for your applications. Learning
                 to program using concurrency is critical to creating
                 faster, more responsive applications, and now you can
                 leverage the Java platform to bring these applications
                 to high-octane life.",
  acknowledgement = ack-nhfb,
  subject =      "Java (Computer program language); Java virtual
                 machine; Parallel processing (Electronic computers);
                 Computer multitasking; Computer programming; Systems
                 programming (Computer science)",
  tableofcontents = "The power and perils of concurrency \\
                 Strategies for concurrency \\
                 Modern Java/JDK concurrency \\
                 Software transactional memory \\
                 Actor-based concurrency",
}

@Article{Taboada:2011:DEJ,
  author =       "Guillermo L. Taboada and Sabela Ramos and Juan
                 Touri{\~n}o and Ram{\'o}n Doallo",
  title =        "Design of efficient {Java} message-passing collectives
                 on multi-core clusters",
  journal =      j-J-SUPERCOMPUTING,
  volume =       "55",
  number =       "2",
  pages =        "126--154",
  month =        feb,
  year =         "2011",
  CODEN =        "JOSUED",
  ISSN =         "0920-8542 (print), 1573-0484 (electronic)",
  ISSN-L =       "0920-8542",
  bibdate =      "Tue Sep 6 21:50:38 MDT 2011",
  bibsource =    "http://springerlink.metapress.com/openurl.asp?genre=issue&issn=0920-8542&volume=55&issue=2;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://www.springerlink.com/openurl.asp?genre=article&issn=0920-8542&volume=55&issue=2&spage=126",
  acknowledgement = ack-nhfb,
  fjournal =     "The Journal of Supercomputing",
  journal-URL =  "http://link.springer.com/journal/11227",
}

@Article{Taboada:2011:DLC,
  author =       "Guillermo L. Taboada and Juan Touri{\~n}o and
                 Ram{\'o}n Doallo and Aamir Shafi and Mark Baker and
                 Bryan Carpenter",
  title =        "Device level communication libraries for
                 high-performance computing in {Java}",
  journal =      j-CCPE,
  volume =       "23",
  number =       "18",
  pages =        "2382--2403",
  day =          "25",
  month =        dec,
  year =         "2011",
  CODEN =        "CCPEBO",
  DOI =          "https://doi.org/10.1002/cpe.1777",
  ISSN =         "1532-0626 (print), 1532-0634 (electronic)",
  ISSN-L =       "1532-0626",
  bibdate =      "Mon Dec 5 10:09:01 MST 2011",
  bibsource =    "http://www.interscience.wiley.com/jpages/1532-0626;
                 https://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Concurrency and Computation: Practice and Experience",
  journal-URL =  "http://www.interscience.wiley.com/jpages/1532-0626",
  onlinedate =   "14 Jun 2011",
}

@Article{Tarau:2011:IST,
  author =       "Paul Tarau",
  title =        "Integrated symbol table, engine and heap memory
                 management in multi-engine {Prolog}",
  journal =      j-SIGPLAN,
  volume =       "46",
  number =       "11",
  pages =        "129--138",
  month =        nov,
  year =         "2011",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2076022.1993497",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Dec 15 07:46:57 MST 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "ISMM '11 conference proceedings.",
  abstract =     "We describe an integrated solution to symbol, heap and
                 logic engine memory management in a context where
                 exchanges of arbitrary Prolog terms occur between
                 multiple dynamically created engines, implemented in a
                 new Java-based experimental Prolog system. As our
                 symbols represent not just Prolog atoms, but also
                 handles to Java objects (including arbitrary size
                 integers and decimals), everything is centered around a
                 symbol garbage collection algorithm ensuring that
                 external objects are shared and exchanged between logic
                 engines efficiently. Taking advantage of a tag-on-data
                 heap representation of Prolog terms, our algorithm
                 performs in-place updates of live symbol references
                 directly on heap cells.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Tate:2011:TWJ,
  author =       "Ross Tate and Alan Leung and Sorin Lerner",
  title =        "Taming wildcards in {Java}'s type system",
  journal =      j-SIGPLAN,
  volume =       "46",
  number =       "6",
  pages =        "614--627",
  month =        jun,
  year =         "2011",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1993316.1993570",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Jun 9 10:23:33 MDT 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Toledo:2011:ACJ,
  author =       "Rodolfo Toledo and Eric Tanter",
  title =        "Access Control in {JavaScript}",
  journal =      j-IEEE-SOFTWARE,
  volume =       "28",
  number =       "5",
  pages =        "76--84",
  month =        sep # "\slash " # oct,
  year =         "2011",
  CODEN =        "IESOEG",
  DOI =          "https://doi.org/10.1109/MS.2010.154",
  ISSN =         "0740-7459 (print), 0740-7459 (electronic)",
  ISSN-L =       "0740-7459",
  bibdate =      "Wed Aug 31 17:16:45 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE Software",
  journal-URL =  "http://www.computer.org/portal/web/csdl/magazines/software",
}

@Book{Topley:2011:JDG,
  author =       "Kim Topley",
  title =        "{JavaFX} developer's guide",
  publisher =    pub-AW,
  address =      pub-AW,
  pages =        "xxxix + 1110",
  year =         "2011",
  ISBN =         "0-321-60165-3",
  ISBN-13 =      "978-0-321-60165-0",
  LCCN =         "????",
  bibdate =      "Thu Dec 1 07:51:47 MST 2011",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 https://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  note =         "Updated for JavaFX 1.3.",
  series =       "Developer's library",
}

@Article{V:2011:BBI,
  author =       "Sharath Chandra V. and S. Selvakumar",
  title =        "{BIXSAN}: browser independent {XSS} sanitizer for
                 prevention of {XSS} attacks",
  journal =      j-SIGSOFT,
  volume =       "36",
  number =       "5",
  pages =        "1--7",
  month =        sep,
  year =         "2011",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/2020976.2020996",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:16:04 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  abstract =     "Proliferation of social networking sites, and web
                 applications which deliver dynamic content to the
                 clients have increased the user created HTML content in
                 the World Wide Web. This user-created HTML content can
                 be a notorious vector for Cross-Site Scripting,(XSS)
                 attacks. XSS attacks have the ability to target
                 websites, steal confidential information of the users,
                 and hijack their accounts, etc. XSS attacks are
                 launched to exploit the vulnerabilities of the poorly
                 developed application code and data processing systems.
                 In particular, improper validation of user created
                 content and un-sanitized custom error messages
                 introduce vulnerability for XSS attacks. It is a
                 challenging task for any security mechanism to filter
                 out only the harmful HTML content and retain safe
                 content with high fidelity and robustness. This has
                 motivated us to develop a mechanism that filters out
                 the harmful HTML content, and allows safe HTML. The
                 existing solutions to XSS attack include use of regular
                 expressions to detect the presence of dynamic content
                 and client side filtering mechanisms such as Noscript
                 and Noxes tool. The drawbacks of these solutions are
                 low fidelity and disallowing of benign HTML. In order
                 to overcome these drawbacks BIXSAN, a Browser
                 Independent XSS SANitizer for prevention of XSS attacks
                 is proposed in this paper. BIXSAN includes the
                 proposition of three pronged strategy. These strategies
                 are as follows: Firstly the use of complete HTML parser
                 is proposed rather than approximating the behavior of
                 parser. The advantage of using complete HTML parser is
                 that it offers high fidelity. Secondly the use of
                 modified browser, viz., JavaScript Tester is proposed
                 to detect the presence of JavaScript for filtering it
                 out. Thirdly, identification of static tags is proposed
                 for allowing the benign HTML. Further, BIXSAN includes
                 the proposition of a parse tree generator at client
                 side browser to reduce the anomalous behavior of
                 browsers. BIXSAN was experimented in various browsers
                 such as Opera, Netscape, Internet Explorer (IE), and
                 Firefox and found to work for all the browsers. From
                 the experiments conducted it has been found that the
                 proposed BIXSAN prevents the injection of XSS attack
                 code successfully. Further, it has been verified that
                 BIXSAN reduces the anomalous behavior of browse.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Villazon:2011:CAW,
  author =       "Alex Villaz{\'o}n and Walter Binder and Philippe Moret
                 and Danilo Ansaloni",
  title =        "Comprehensive aspect weaving for {Java}",
  journal =      j-SCI-COMPUT-PROGRAM,
  volume =       "76",
  number =       "11",
  pages =        "1015--1036",
  day =          "1",
  month =        nov,
  year =         "2011",
  CODEN =        "SCPGD4",
  ISSN =         "0167-6423 (print), 1872-7964 (electronic)",
  ISSN-L =       "0167-6423",
  bibdate =      "Tue Jun 21 10:31:56 MDT 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://www.sciencedirect.com/science/journal/01676423",
  acknowledgement = ack-nhfb,
  fjournal =     "Science of Computer Programming",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01676423",
}

@Article{Wagner:2011:CMM,
  author =       "Gregor Wagner and Andreas Gal and Christian Wimmer and
                 Brendan Eich and Michael Franz",
  title =        "Compartmental memory management in a modern web
                 browser",
  journal =      j-SIGPLAN,
  volume =       "46",
  number =       "11",
  pages =        "119--128",
  month =        nov,
  year =         "2011",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2076022.1993496",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Dec 15 07:46:57 MST 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "ISMM '11 conference proceedings.",
  abstract =     "Since their inception, the usage pattern of web
                 browsers has changed substantially. Rather than
                 sequentially navigating static web sites, modern web
                 browsers often manage a large number of simultaneous
                 tabs displaying dynamic web content, each of which
                 might be running a substantial amount of client-side
                 JavaScript code. This environment introduced a new
                 degree of parallelism that was not fully embraced by
                 the underlying JavaScript virtual machine architecture.
                 We propose a novel abstraction for multiple disjoint
                 JavaScript heaps, which we call compartments. We use
                 the notion of document origin to cluster objects into
                 separate compartments. Objects within a compartment can
                 reference each other directly.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Wagner:2011:SJV,
  author =       "Gregor Wagner and Andreas Gal and Michael Franz",
  title =        "``Slimming'' a {Java} virtual machine by way of cold
                 code removal and optimistic partial program loading",
  journal =      j-SCI-COMPUT-PROGRAM,
  volume =       "76",
  number =       "11",
  pages =        "1037--1053",
  day =          "1",
  month =        nov,
  year =         "2011",
  CODEN =        "SCPGD4",
  ISSN =         "0167-6423 (print), 1872-7964 (electronic)",
  ISSN-L =       "0167-6423",
  bibdate =      "Tue Jun 21 10:31:56 MDT 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://www.sciencedirect.com/science/journal/01676423",
  acknowledgement = ack-nhfb,
  fjournal =     "Science of Computer Programming",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01676423",
}

@Book{Wampler:2011:FPJ,
  author =       "Dean Wampler",
  title =        "Functional programming for {Java} developers",
  publisher =    pub-ORA,
  address =      pub-ORA:adr,
  pages =        "xi + 72",
  year =         "2011",
  ISBN =         "1-4493-1265-9, 1-4493-1103-2",
  ISBN-13 =      "978-1-4493-1265-7, 978-1-4493-1103-2",
  LCCN =         "QA76.62 .W36 2011",
  bibdate =      "Wed Jul 12 16:13:28 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/jfunctprogram.bib;
                 library.mit.edu:9909/mit01",
  URL =          "http://proquest.safaribooksonline.com/9781449312657",
  acknowledgement = ack-nhfb,
  remark =       "``Tools for better concurrency, abstraction, and
                 agility''--Cover.",
  subject =      "Functional programming (Computer science); Java
                 (Computer program language)",
}

@Article{Wang:2011:EEU,
  author =       "Alf Inge Wang",
  title =        "Extensive Evaluation of Using a Game Project in a
                 Software Architecture Course",
  journal =      j-TOCE,
  volume =       "11",
  number =       "1",
  pages =        "5:1--5:??",
  month =        feb,
  year =         "2011",
  CODEN =        "????",
  ISSN =         "1946-6226",
  bibdate =      "Mon Feb 28 16:08:34 MST 2011",
  bibsource =    "http://www.acm.org/pubs/toce;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "This article describes an extensive evaluation of
                 introducing a game project to a software architecture
                 course. In this project, university students have to
                 construct and design a type of software architecture,
                 evaluate the architecture, implement an application
                 based on the architecture, and test this
                 implementation. In previous years, the domain of the
                 software architecture project has been a robot
                 controller for navigating a maze. In 2008, the students
                 on the software architecture course chose between the
                 two domains: Khepera robot simulation in Java and XNA
                 game development in C#. Independent of the domain
                 chosen, the students had to go through the same phases,
                 produce the same documents based on the same templates,
                 and follow exactly the same process.",
  acknowledgement = ack-nhfb,
  articleno =    "5",
  fjournal =     "ACM Transactions on Computing Education",
}

@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/java2010.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,
  articleno =    "12",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Wu:2011:RTS,
  author =       "Peng Wu and Hiroshige Hayashizaki and Hiroshi Inoue
                 and Toshio Nakatani",
  title =        "Reducing trace selection footprint for large-scale
                 {Java} applications without performance loss",
  journal =      j-SIGPLAN,
  volume =       "46",
  number =       "10",
  pages =        "789--804",
  month =        oct,
  year =         "2011",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2076021.2048127",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Dec 15 07:46:53 MST 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "OOPSLA '11 conference proceedings.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Wurthinger:2011:AED,
  author =       "Thomas W{\"u}rthinger and Walter Binder and Danilo
                 Ansaloni and Philippe Moret and Hanspeter
                 M{\"o}ssenb{\"o}ck",
  title =        "Applications of enhanced dynamic code evolution for
                 {Java} in {GUI} development and dynamic aspect-oriented
                 programming",
  journal =      j-SIGPLAN,
  volume =       "46",
  number =       "2",
  pages =        "123--126",
  month =        feb,
  year =         "2011",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/1942788.1868312",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Feb 14 16:37:34 MST 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "While dynamic code evolution in object-oriented
                 systems is an important feature supported by dynamic
                 languages, there is currently only limited support for
                 dynamic code evolution in high-performance,
                 state-of-the-art runtime systems for statically typed
                 languages, such as the Java Virtual Machine. In this
                 tool demonstration, we present the Dynamic Code
                 Evolution VM, which is based on a recent version of
                 Oracle's state-of-the-art Java HotSpot(TM) VM and
                 allows unlimited changes to loaded classes at runtime.
                 Based on the Dynamic Code Evolution VM, we developed an
                 enhanced version of the Mantisse GUI builder (which is
                 part of the NetBeans IDE) that allows adding GUI
                 components without restarting the application under
                 development.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Wurthinger:2011:SAR,
  author =       "Thomas W{\"u}rthinger and Danilo Ansaloni and Walter
                 Binder and Christian Wimmer and Hanspeter
                 M{\"o}ssenb{\"o}ck",
  title =        "Safe and atomic run-time code evolution for {Java} and
                 its application to dynamic {AOP}",
  journal =      j-SIGPLAN,
  volume =       "46",
  number =       "10",
  pages =        "825--844",
  month =        oct,
  year =         "2011",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2076021.2048129",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Dec 15 07:46:53 MST 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "OOPSLA '11 conference proceedings.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Afek:2012:ISJ,
  author =       "Yehuda Afek and Nir Shavit and Moran Tzafrir",
  title =        "Interrupting snapshots and the {Java} size method",
  journal =      j-J-PAR-DIST-COMP,
  volume =       "72",
  number =       "7",
  pages =        "880--888",
  month =        jul,
  year =         "2012",
  CODEN =        "JPDCER",
  DOI =          "https://doi.org/10.1016/j.jpdc.2012.03.007",
  ISSN =         "0743-7315 (print), 1096-0848 (electronic)",
  ISSN-L =       "0743-7315",
  bibdate =      "Thu May 17 13:55:41 MDT 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/jpardistcomp.bib;
                 http://www.sciencedirect.com/science/journal/07437315",
  URL =          "http://www.sciencedirect.com/science/article/pii/S074373151200072X",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Parallel and Distributed Computing",
  journal-URL =  "http://www.sciencedirect.com/science/journal/07437315",
}

@Book{Altman:2012:USM,
  author =       "Yair M. Altman",
  title =        "Undocumented secrets of {MATLAB--Java} programming",
  publisher =    pub-CRC,
  address =      pub-CRC:adr,
  pages =        "xxi + 663 + 16",
  year =         "2012",
  ISBN =         "1-4398-6904-9 (e-book), 1-4398-6903-0 (hardback),
                 1-4398-6903-0",
  ISBN-13 =      "978-1-4398-6904-8 (e-book), 978-1-4398-6903-1
                 (hardback), 978-1-4398-6903-1",
  LCCN =         "QA297 .A544 2012",
  bibdate =      "Fri Nov 16 08:10:20 MST 2012",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/matlab.bib;
                 https://www.math.utah.edu/pub/tex/bib/numana2010.bib",
  acknowledgement = ack-nhfb,
  subject =      "MATLAB; Numerical analysis; Data processing; Java
                 (Computer program language); COMPUTERS / Programming /
                 Algorithms; COMPUTERS / Computer Engineering;
                 MATHEMATICS / Number Systems. MATHEMATICS / Numerical
                 Analysis",
  tableofcontents = "1.: Introduction to Java in MATLAB \\
                 2.: Using non-GUI Java libraries in MATLAB \\
                 3.: Rich GUI using Java Swing \\
                 4.: Uitools \\
                 5.: Built-in MATLAB widgets and Java classes \\
                 6.: Customizing MATLAB controls \\
                 7.: The Java frame \\
                 8.: The MATLAB desktop \\
                 9.: Using MATLAB from within Java \\
                 10.: Putting it all together \\
                 Appendix A.: What Is Java? \\
                 Appendix B.: UDD \\
                 Appendix C.: Open questions",
}

@Article{Anonymous:2012:AMJ,
  author =       "Anonymous",
  title =        "Another major {Java} panic",
  journal =      j-NETWORK-SECURITY,
  volume =       "2012",
  number =       "9",
  pages =        "19--20",
  month =        sep,
  year =         "2012",
  CODEN =        "NTSCF5",
  DOI =          "https://doi.org/10.1016/S1353-4858(12)70084-3",
  ISSN =         "1353-4858 (print), 1872-9371 (electronic)",
  ISSN-L =       "1353-4858",
  bibdate =      "Mon Dec 4 17:00:46 MST 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/network-security.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S1353485812700843",
  acknowledgement = ack-nhfb,
  fjournal =     "Network Security",
  journal-URL =  "https://www.sciencedirect.com/journal/network-security",
}

@Article{Ansaloni:2012:DAO,
  author =       "Danilo Ansaloni and Walter Binder and Philippe Moret
                 and Alex Villaz{\'o}n",
  title =        "Dynamic Aspect-Oriented Programming in {Java}: The
                 {HotWave} Experience",
  journal =      j-LECT-NOTES-COMP-SCI,
  volume =       "7271",
  pages =        "92--122",
  year =         "2012",
  CODEN =        "LNCSD9",
  DOI =          "https://doi.org/10.1007/978-3-642-35551-6_3",
  ISSN =         "0302-9743 (print), 1611-3349 (electronic)",
  ISSN-L =       "0302-9743",
  bibdate =      "Wed Dec 19 15:18:55 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/lncs2012d.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-642-35551-6_3/",
  acknowledgement = ack-nhfb,
  book-DOI =     "https://doi.org/10.1007/978-3-642-35551-6",
  book-URL =     "http://www.springerlink.com/content/978-3-642-35551-6",
  fjournal =     "Lecture Notes in Computer Science",
}

@Article{Arcaini:2012:CCM,
  author =       "Paolo Arcaini and Angelo Gargantini and Elvinia
                 Riccobene",
  title =        "{CoMA}: Conformance Monitoring of {Java} Programs by
                 Abstract State Machines",
  journal =      j-LECT-NOTES-COMP-SCI,
  volume =       "7186",
  pages =        "223--238",
  year =         "2012",
  CODEN =        "LNCSD9",
  DOI =          "https://doi.org/10.1007/978-3-642-29860-8_17",
  ISSN =         "0302-9743 (print), 1611-3349 (electronic)",
  ISSN-L =       "0302-9743",
  bibdate =      "Wed Dec 19 15:25:51 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/lncs2012b.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-642-29860-8_17/",
  acknowledgement = ack-nhfb,
  book-DOI =     "https://doi.org/10.1007/978-3-642-29860-8",
  book-URL =     "http://www.springerlink.com/content/978-3-642-29860-8",
  fjournal =     "Lecture Notes in Computer Science",
}

@Article{Austin:2012:MFD,
  author =       "Thomas H. Austin and Cormac Flanagan",
  title =        "Multiple facets for dynamic information flow",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "1",
  pages =        "165--178",
  month =        jan,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2103621.2103677",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Mar 15 18:16:55 MDT 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "JavaScript has become a central technology of the web,
                 but it is also 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. We implement information flow controls in
                 Firefox to help prevent violations of data
                 confidentiality and integrity. Most previous
                 information flow techniques have primarily relied on
                 either static type systems, which are a poor fit for
                 JavaScript, or on dynamic analyses that sometimes get
                 stuck due to problematic implicit flows, even in
                 situations where the target web application correctly
                 satisfies the desired security policy. We introduce
                 faceted values, a new mechanism for providing
                 information flow security in a dynamic manner that
                 overcomes these limitations. Taking inspiration from
                 secure multi-execution, we use faceted values to
                 simultaneously and efficiently simulate multiple
                 executions for different security levels, thus
                 providing non-interference with minimal overhead, and
                 without the reliance on the stuck executions of prior
                 dynamic approaches.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "POPL '12 conference proceedings.",
}

@Article{Avvenuti:2012:JTC,
  author =       "Marco Avvenuti and Cinzia Bernardeschi and Nicoletta
                 De Francesco and Paolo Masci",
  title =        "{JCSI}: a tool for checking secure information flow in
                 {Java Card} applications",
  journal =      j-J-SYST-SOFTW,
  volume =       "85",
  number =       "11",
  pages =        "2479--2493",
  month =        nov,
  year =         "2012",
  CODEN =        "JSSODM",
  DOI =          "https://doi.org/10.1016/j.jss.2012.05.061",
  ISSN =         "0164-1212 (print), 1873-1228 (electronic)",
  ISSN-L =       "0164-1212",
  bibdate =      "Mon Aug 20 17:08:56 MDT 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/jsystsoftw.bib;
                 http://www.sciencedirect.com/science/journal/01641212",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0164121212001513",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Systems and Software",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01641212",
}

@Article{Baar:2012:DEP,
  author =       "Thomas Baar and Philipp Kumar",
  title =        "Detecting Entry Points in {Java} Libraries",
  journal =      j-LECT-NOTES-COMP-SCI,
  volume =       "7162",
  pages =        "42--54",
  year =         "2012",
  CODEN =        "LNCSD9",
  DOI =          "https://doi.org/10.1007/978-3-642-29709-0_6",
  ISSN =         "0302-9743 (print), 1611-3349 (electronic)",
  ISSN-L =       "0302-9743",
  bibdate =      "Wed Dec 19 15:25:23 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/lncs2012b.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-642-29709-0_6/",
  acknowledgement = ack-nhfb,
  book-DOI =     "https://doi.org/10.1007/978-3-642-29709-0",
  book-URL =     "http://www.springerlink.com/content/978-3-642-29709-0",
  fjournal =     "Lecture Notes in Computer Science",
}

@Article{Barbu:2012:ARA,
  author =       "Guillaume Barbu and Philippe Hoogvorst",
  title =        "Application-Replay Attack on {Java} Cards: When the
                 Garbage Collector Gets Confused",
  journal =      j-LECT-NOTES-COMP-SCI,
  volume =       "7159",
  pages =        "1--13",
  year =         "2012",
  CODEN =        "LNCSD9",
  DOI =          "https://doi.org/10.1007/978-3-642-28166-2_1",
  ISSN =         "0302-9743 (print), 1611-3349 (electronic)",
  ISSN-L =       "0302-9743",
  bibdate =      "Wed Dec 19 15:25:19 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/lncs2012b.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-642-28166-2_1/",
  acknowledgement = ack-nhfb,
  book-DOI =     "https://doi.org/10.1007/978-3-642-28166-2",
  book-URL =     "http://www.springerlink.com/content/978-3-642-28166-2",
  fjournal =     "Lecture Notes in Computer Science",
}

@Article{Bedla:2012:SSJ,
  author =       "Mariusz Bedla and Krzysztof Sapiecha",
  title =        "Scalable Store of {Java} Objects Using Range
                 Partitioning",
  journal =      j-LECT-NOTES-COMP-SCI,
  volume =       "7054",
  pages =        "84--93",
  year =         "2012",
  CODEN =        "LNCSD9",
  DOI =          "https://doi.org/10.1007/978-3-642-28038-2_7",
  ISSN =         "0302-9743 (print), 1611-3349 (electronic)",
  ISSN-L =       "0302-9743",
  bibdate =      "Wed Dec 19 15:23:17 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/lncs2012a.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-642-28038-2_7/",
  acknowledgement = ack-nhfb,
  book-DOI =     "https://doi.org/10.1007/978-3-642-28038-2",
  book-URL =     "http://www.springerlink.com/content/978-3-642-28038-2",
  fjournal =     "Lecture Notes in Computer Science",
}

@Article{Bellia:2012:ERT,
  author =       "Marco Bellia and M. Eugenia Occhiuto",
  title =        "The Equivalence of Reduction and Translation Semantics
                 of {Java} Simple Closures",
  journal =      j-FUND-INFO,
  volume =       "119",
  number =       "3--4",
  pages =        "249--264",
  month =        aug,
  year =         "2012",
  CODEN =        "FUMAAJ",
  DOI =          "https://doi.org/10.3233/FI-2012-736",
  ISSN =         "0169-2968 (print), 1875-8681 (electronic)",
  ISSN-L =       "0169-2968",
  bibdate =      "Sat Mar 5 17:15:33 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/fundinfo2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Fundamenta Informaticae",
  journal-URL =  "http://content.iospress.com/journals/fundamenta-informaticae",
}

@Article{Bhattacharya:2012:DLI,
  author =       "Suparna Bhattacharya and Karthick Rajamani and K.
                 Gopinath and Manish Gupta",
  title =        "Does lean imply green?: a study of the power
                 performance implications of {Java} runtime bloat",
  journal =      j-SIGMETRICS,
  volume =       "40",
  number =       "1",
  pages =        "259--270",
  month =        jun,
  year =         "2012",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/2318857.2254789",
  ISSN =         "0163-5999 (print), 1557-9484 (electronic)",
  ISSN-L =       "0163-5999",
  bibdate =      "Fri Nov 9 11:06:39 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigmetrics.bib",
  abstract =     "The presence of software bloat in large flexible
                 software systems can hurt energy efficiency. However,
                 identifying and mitigating bloat is fairly effort
                 intensive. To enable such efforts to be directed where
                 there is a substantial potential for energy savings, we
                 investigate the impact of bloat on power consumption
                 under different situations. We conduct the first
                 systematic experimental study of the joint
                 power-performance implications of bloat across a range
                 of hardware and software configurations on modern
                 server platforms. The study employs controlled
                 experiments to expose different effects of a common
                 type of Java runtime bloat, excess temporary objects,
                 in the context of the SPECPower_ssj2008 workload. We
                 introduce the notion of equi-performance power
                 reduction to characterize the impact, in addition to
                 peak power comparisons. The results show a wide
                 variation in energy savings from bloat reduction across
                 these configurations. Energy efficiency benefits at
                 peak performance tend to be most pronounced when bloat
                 affects a performance bottleneck and non-bloated
                 resources have low energy-proportionality.
                 Equi-performance power savings are highest when bloated
                 resources have a high degree of energy proportionality.
                 We develop an analytical model that establishes a
                 general relation between resource pressure caused by
                 bloat and its energy efficiency impact under different
                 conditions of resource bottlenecks and energy
                 proportionality. Applying the model to different
                 ``what-if'' scenarios, we predict the impact of bloat
                 reduction and corroborate these predictions with
                 empirical observations. Our work shows that the
                 prevalent software-only view of bloat is inadequate for
                 assessing its power-performance impact and instead
                 provides a full systems approach for reasoning about
                 its implications.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGMETRICS Performance Evaluation Review",
  journal-URL =  "http://portal.acm.org/toc.cfm?id=J618",
}

@Article{Bluemke:2012:DTJ,
  author =       "Ilona Bluemke and Artur Rembiszewski",
  title =        "Dataflow Testing of {Java} Programs with {DFC}",
  journal =      j-LECT-NOTES-COMP-SCI,
  volume =       "7054",
  pages =        "215--228",
  year =         "2012",
  CODEN =        "LNCSD9",
  DOI =          "https://doi.org/10.1007/978-3-642-28038-2_17",
  ISSN =         "0302-9743 (print), 1611-3349 (electronic)",
  ISSN-L =       "0302-9743",
  bibdate =      "Wed Dec 19 15:23:17 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/lncs2012a.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-642-28038-2_17/",
  acknowledgement = ack-nhfb,
  book-DOI =     "https://doi.org/10.1007/978-3-642-28038-2",
  book-URL =     "http://www.springerlink.com/content/978-3-642-28038-2",
  fjournal =     "Lecture Notes in Computer Science",
}

@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:??",
  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/java2000.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 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,
  articleno =    "7",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Boland:2012:JCC,
  author =       "Tim Boland and Paul E. Black",
  title =        "{Juliet 1.1 C/C++} and {Java Test Suite}",
  journal =      j-COMPUTER,
  volume =       "45",
  number =       "10",
  pages =        "88--90",
  month =        oct,
  year =         "2012",
  CODEN =        "CPTRB4",
  DOI =          "https://doi.org/10.1109/MC.2012.345",
  ISSN =         "0018-9162 (print), 1558-0814 (electronic)",
  ISSN-L =       "0018-9162",
  bibdate =      "Mon Oct 22 06:38:12 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/computer2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Computer",
  journal-URL =  "http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=2",
}

@Article{Bourdykine:2012:LAM,
  author =       "Pavel Bourdykine and Stephen M. Watt",
  title =        "Lightweight Abstraction for Mathematical Computation
                 in {Java}",
  journal =      j-LECT-NOTES-COMP-SCI,
  volume =       "7442",
  pages =        "47--59",
  year =         "2012",
  CODEN =        "LNCSD9",
  DOI =          "https://doi.org/10.1007/978-3-642-32973-9_5",
  ISSN =         "0302-9743 (print), 1611-3349 (electronic)",
  ISSN-L =       "0302-9743",
  bibdate =      "Wed Dec 19 15:22:40 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/lncs2012g.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-642-32973-9_5/",
  acknowledgement = ack-nhfb,
  book-DOI =     "https://doi.org/10.1007/978-3-642-32973-9",
  book-URL =     "http://www.springerlink.com/content/978-3-642-32973-9",
  fjournal =     "Lecture Notes in Computer Science",
}

@Article{Bradel:2012:ITJ,
  author =       "Bory J. Bradel and Tarek S. Abdelrahman",
  title =        "Inlining with traces in {Java} programs",
  journal =      j-INT-J-COMPUT-SYST-SCI-ENG,
  volume =       "27",
  number =       "4",
  pages =        "??--??",
  month =        "????",
  year =         "2012",
  CODEN =        "CSSEEI",
  ISSN =         "0267-6192",
  ISSN-L =       "0267-6192",
  bibdate =      "Tue Dec 3 12:04:33 MST 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/computsystscieng.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "International Journal of Computer Systems Science and
                 Engineering",
}

@Article{Brockschmidt:2012:ADN,
  author =       "Marc Brockschmidt and Thomas Str{\"o}der and Carsten
                 Otto and J{\"u}rgen Giesl",
  title =        "Automated Detection of Non-termination and {{\tt
                 NullPointerException}}s for {Java} Bytecode",
  journal =      j-LECT-NOTES-COMP-SCI,
  volume =       "7421",
  pages =        "123--141",
  year =         "2012",
  CODEN =        "LNCSD9",
  DOI =          "https://doi.org/10.1007/978-3-642-31762-0_9",
  ISSN =         "0302-9743 (print), 1611-3349 (electronic)",
  ISSN-L =       "0302-9743",
  bibdate =      "Wed Dec 19 15:22:12 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/lncs2012g.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-642-31762-0_9/",
  acknowledgement = ack-nhfb,
  book-DOI =     "https://doi.org/10.1007/978-3-642-31762-0",
  book-URL =     "http://www.springerlink.com/content/978-3-642-31762-0",
  fjournal =     "Lecture Notes in Computer Science",
}

@Article{Brockschmidt:2012:ATP,
  author =       "Marc Brockschmidt and Richard Musiol and Carsten Otto
                 and J{\"u}rgen Giesl",
  title =        "Automated Termination Proofs for {Java} Programs with
                 Cyclic Data",
  journal =      j-LECT-NOTES-COMP-SCI,
  volume =       "7358",
  pages =        "105--122",
  year =         "2012",
  CODEN =        "LNCSD9",
  DOI =          "https://doi.org/10.1007/978-3-642-31424-7_13",
  ISSN =         "0302-9743 (print), 1611-3349 (electronic)",
  ISSN-L =       "0302-9743",
  bibdate =      "Wed Dec 19 15:20:49 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/lncs2012f.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-642-31424-7_13/",
  acknowledgement = ack-nhfb,
  book-DOI =     "https://doi.org/10.1007/978-3-642-31424-7",
  book-URL =     "http://www.springerlink.com/content/978-3-642-31424-7",
  fjournal =     "Lecture Notes in Computer Science",
}

@Article{Brown:2012:BRF,
  author =       "Neil Brown",
  title =        "Book Review: {{\booktitle{Functional Programming for
                 Java Developers --- Tools for Better Concurrency,
                 Abstraction, and Agility}}, By Dean Wampler, O'Reilly
                 Media, July 2011, ISBN-13: 978-1-4493-1103-2, 90 pp.}",
  journal =      j-J-FUNCT-PROGRAM,
  volume =       "22",
  number =       "6",
  pages =        "853--854",
  month =        nov,
  year =         "2012",
  CODEN =        "JFPRES",
  DOI =          "https://doi.org/10.1017/S0956796812000299",
  ISSN =         "0956-7968 (print), 1469-7653 (electronic)",
  ISSN-L =       "0956-7968",
  bibdate =      "Wed Jul 12 06:49:21 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/jfunctprogram.bib",
  URL =          "https://www.cambridge.org/core/product/02755329E5B068C2D403EE6722FCBD06",
  acknowledgement = ack-nhfb,
  ajournal =     "J. Funct. Program.",
  fjournal =     "Journal of Functional Programming",
  journal-URL =  "http://journals.cambridge.org/action/displayJournal?jid=JFP",
  onlinedate =   "01 August 2012",
}

@Article{Burdette:2012:ECJ,
  author =       "Philip F. Burdette and William F. Jones and Brian C.
                 Blose and Gregory M. Kapfhammer",
  title =        "An empirical comparison of {Java} remote communication
                 primitives for intra-node data transmission",
  journal =      j-SIGMETRICS,
  volume =       "39",
  number =       "4",
  pages =        "2--11",
  month =        apr,
  year =         "2012",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/2185395.2185397",
  ISSN =         "0163-5999 (print), 1557-9484 (electronic)",
  ISSN-L =       "0163-5999",
  bibdate =      "Fri Nov 9 11:06:38 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigmetrics.bib",
  abstract =     "This paper presents a benchmarking suite that measures
                 the performance of using sockets and eXtensible Markup
                 Language remote procedure calls (XML-RPC) to exchange
                 intra-node messages between Java virtual machines
                 (JVMs). The paper also reports on an empirical study
                 comparing sockets and XML-RPC with response time
                 measurements from timers that use both operating system
                 tools and Java language instrumentation. By leveraging
                 packet filters inside the GNU/Linux kernel, the
                 benchmark suite also calculates network resource
                 consumption. Moreover, the framework interprets the
                 response time results in light of memory subsystem
                 metrics characterizing the behavior of the JVM. The
                 empirical findings indicate that sockets perform better
                 when transmitting small to very large objects, while
                 XML-RPC exhibits lower response time than sockets with
                 extremely large bulk data transfers. The experiments
                 reveal trade-offs in performance and thus represent the
                 first step towards determining if Java remote
                 communication primitives can support the efficient
                 exchange of intra-node messages.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGMETRICS Performance Evaluation Review",
  journal-URL =  "http://portal.acm.org/toc.cfm?id=J618",
}

@Article{Burnim:2012:NIN,
  author =       "Jacob Burnim and Tayfun Elmas and George Necula and
                 Koushik Sen",
  title =        "{NDetermin}: inferring nondeterministic sequential
                 specifications for parallelism correctness",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "8",
  pages =        "329--330",
  month =        aug,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2370036.2145879",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Wed Sep 12 12:11:57 MDT 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "PPOPP '12 conference proceedings.",
  abstract =     "Nondeterministic Sequential (NDSeq) specifications
                 have been proposed as a means for separating the
                 testing, debugging, and verifying of a program's
                 parallelism correctness and its sequential functional
                 correctness. In this work, we present a technique that,
                 given a few representative executions of a parallel
                 program, combines dynamic data flow analysis and
                 Minimum-Cost Boolean Satisfiability (MinCostSAT)
                 solving for automatically inferring a likely NDSeq
                 specification for the parallel program. For a number of
                 Java benchmarks, our tool NDetermin infers equivalent
                 or stronger NDSeq specifications than those previously
                 written manually.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Burnim:2012:SCS,
  author =       "Jacob Burnim and George Necula and Koushik Sen",
  title =        "Specifying and checking semantic atomicity for
                 multithreaded programs",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "4",
  pages =        "79--90",
  month =        apr,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2248487.1950377",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Jun 7 08:15:03 MDT 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "In practice, it is quite difficult to write correct
                 multithreaded programs due to the potential for
                 unintended and nondeterministic interference between
                 parallel threads. A fundamental correctness property
                 for such programs is atomicity---a block of code in a
                 program is atomic if, for any parallel execution of the
                 program, there is an execution with the same overall
                 program behavior in which the block is executed
                 serially. We propose semantic atomicity, a
                 generalization of atomicity with respect to a
                 programmer-defined notion of equivalent behavior. We
                 propose an assertion framework in which a programmer
                 can use bridge predicates to specify noninterference
                 properties at the level of abstraction of their
                 application. Further, we propose a novel algorithm for
                 systematically testing atomicity specifications on
                 parallel executions with a bounded number of
                 interruptions---i.e. atomic blocks whose execution is
                 interleaved with that of other threads. We further
                 propose a set of sound heuristics and optional user
                 annotations that increase the efficiency of checking
                 atomicity specifications in the common case where the
                 specifications hold. We have implemented our assertion
                 framework for specifying and checking semantic
                 atomicity for parallel Java programs, and we have
                 written semantic atomicity specifications for a number
                 of benchmarks. We found that using bridge predicates
                 allowed us to specify the natural and intended atomic
                 behavior of a wider range of programs than did previous
                 approaches. Further, in checking our specifications, we
                 found several previously unknown bugs, including in the
                 widely-used java.util.concurrent library.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "ASPLOS '12 conference proceedings.",
}

@Article{Cao:2012:YYP,
  author =       "Ting Cao and Stephen M. Blackburn and Tiejun Gao and
                 Kathryn S. McKinley",
  title =        "The yin and yang of power and performance for
                 asymmetric hardware and managed software",
  journal =      j-COMP-ARCH-NEWS,
  volume =       "40",
  number =       "3",
  pages =        "225--236",
  month =        jun,
  year =         "2012",
  CODEN =        "CANED2",
  DOI =          "https://doi.org/10.1145/2366231.2337185",
  ISSN =         "0163-5964 (print), 1943-5851 (electronic)",
  ISSN-L =       "0163-5964",
  bibdate =      "Thu Sep 6 10:21:07 MDT 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigarch.bib",
  note =         "ISCA '12 conference proceedings.",
  abstract =     "On the hardware side, asymmetric multicore processors
                 present software with the challenge and opportunity of
                 optimizing in two dimensions: performance and power.
                 Asymmetric multicore processors (AMP) combine
                 general-purpose big (fast, high power) cores and small
                 (slow, low power) cores to meet power constraints.
                 Realizing their energy efficiency opportunity requires
                 workloads with differentiated performance and power
                 characteristics. On the software side, managed
                 workloads written in languages such as C\#, Java,
                 JavaScript, and PHP are ubiquitous. Managed languages
                 abstract over hardware using Virtual Machine (VM)
                 services (garbage collection, interpretation, and/or
                 just-in-time compilation) that together impose
                 substantial energy and performance costs, ranging from
                 10\% to over 80\%. We show that these services manifest
                 a differentiated performance and power workload. To
                 differing degrees, they are parallel, asynchronous,
                 communicate infrequently, and are not on the
                 application?s critical path. We identify a synergy
                 between AMP and VM services that we exploit to attack
                 the 40\% average energy overhead due to VM services.
                 Using measurements and very conservative models, we
                 show that adding small cores tailored for VM services
                 should deliver, at least, improvements in performance
                 of 13\%, energy of 7\%, and performance per energy of
                 22\%. The yin of VM services is overhead, but it meets
                 the yang of small cores on an AMP. The yin of AMP is
                 exposed hardware complexity, but it meets the yang of
                 abstraction in managed languages. VM services fulfill
                 the AMP requirement for an asynchronous, non-critical,
                 differentiated, parallel, and ubiquitous workload to
                 deliver energy efficiency. Generalizing this approach
                 beyond system software to applications will require
                 substantially more software and hardware investment,
                 but these results show the potential energy efficiency
                 gains are significant.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGARCH Computer Architecture News",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J89",
}

@Article{Ceccarello:2012:TGC,
  author =       "Matteo Ceccarello and Nastaran Shafiei",
  title =        "Tools to generate and check consistency of model
                 classes for {Java PathFinder}",
  journal =      j-SIGSOFT,
  volume =       "37",
  number =       "6",
  pages =        "1--5",
  month =        nov,
  year =         "2012",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/2382756.2382796",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:16:18 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  abstract =     "Java PathFinder (JPF) is a model checker for Java
                 applications. Like any other model checker, JPF has to
                 combat the notorious state space explosion problem.
                 Since JPF is a JVM, it can only model check Java
                 bytecode and needs to handle native calls differently.
                 JPF tackles the state space explosion problem and
                 handles native calls by means of so-called model
                 classes and native peers. In this paper we focus on
                 model classes. For a class that either causes a state
                 space explosion or that contains native calls, one can
                 introduce a model class that either abstracts away
                 particular details or implements the native call in
                 Java. Rather than model checking the original class,
                 JPF model checks the model class instead. Writing such
                 model classes is time consuming and error prone. In
                 this paper we propose two tools to assist with the
                 development of model classes. The one tool generates a
                 skeleton of a model class. The other tool checks
                 whether a model class is consistent with the original
                 class.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Chanda:2012:TBS,
  author =       "Jayeeta Chanda and Sabnam Sengupta and Ananya Kanjilal
                 and Swapan Bhattacharya",
  title =        "Traceability between service component and class: a
                 model based approach",
  journal =      j-SIGSOFT,
  volume =       "37",
  number =       "6",
  pages =        "1--5",
  month =        nov,
  year =         "2012",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/2382756.2382761",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:16:18 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  abstract =     "Service components are the key to the development of a
                 service-oriented solution as they provide the
                 implementation of the services. The implementation of
                 Service components provides the actual function of the
                 component and can be defined with one or more Java
                 classes. We propose a model named Service Component to
                 Class (SC2C) that maps the service components of an
                 application with that of the classes that implement the
                 service components. We also propose a visual model as a
                 part of SC2C that represents the classes and
                 relationship among classes. This model helps to
                 establish traceability among service components and
                 classes. We also introduce some traceability metrics to
                 measure traceability between the artifacts of Service
                 Oriented Architecture (SOA) and Object Oriented (OO)
                 paradigms. This work, along with our earlier work, help
                 in Software Configuration Management of a SOA
                 application. We provide an insurance system case study
                 to illustrate our approach.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Chang:2012:IOT,
  author =       "Mason Chang and Bernd Mathiske and Edwin Smith and
                 Avik Chaudhuri and Andreas Gal and Michael Bebenita and
                 Christian Wimmer and Michael Franz",
  title =        "The impact of optional type information on {JIT}
                 compilation of dynamically typed languages",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "2",
  pages =        "13--24",
  month =        feb,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2168696.2047853",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Apr 20 17:34:09 MDT 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Optionally typed languages enable direct performance
                 comparisons between untyped and type annotated source
                 code. We present a comprehensive performance evaluation
                 of two different JIT compilers in the context of
                 ActionScript, a production-quality optionally typed
                 language. One JIT compiler is optimized for quick
                 compilation rather than JIT compiled code performance.
                 The second JIT compiler is a more aggressively
                 optimizing compiler, performing both high-level and
                 low-level optimizations. We evaluate both JIT compilers
                 directly on the same benchmark suite, measuring their
                 performance changes across fully typed, partially
                 typed, and untyped code. Such evaluations are
                 especially relevant to dynamically typed languages such
                 as JavaScript, which are currently evaluating the idea
                 of adding optional type annotations. We demonstrate
                 that low-level optimizations rarely accelerate the
                 program enough to pay back the investment into
                 performing them in an optionally typed language. Our
                 experiments and data demonstrate that high-level
                 optimizations are required to improve performance by
                 any significant amount.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "DSL '11 conference proceedings.",
}

@Article{Chevalier-Boisvert:2012:BSH,
  author =       "Maxime Chevalier-Boisvert and Erick Lavoie and Marc
                 Feeley and Bruno Dufour",
  title =        "Bootstrapping a self-hosted research virtual machine
                 for {JavaScript}: an experience report",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "2",
  pages =        "61--72",
  month =        feb,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2168696.2047858",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Apr 20 17:34:09 MDT 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "JavaScript is one of the most widely used dynamic
                 languages. The performance of existing JavaScript VMs,
                 however, is lower than that of VMs for static
                 languages. There is a need for a research VM to easily
                 explore new implementation approaches. This paper
                 presents the Tachyon JavaScript VM which was designed
                 to be flexible and to allow experimenting with new
                 approaches for the execution of JavaScript. The Tachyon
                 VM is itself implemented in JavaScript and currently
                 supports a subset of the full language that is
                 sufficient to bootstrap itself. The paper discusses the
                 architecture of the system and in particular the
                 bootstrapping of a self-hosted VM. Preliminary
                 performance results indicate that our VM, with few
                 optimizations, can already execute code faster than a
                 commercial JavaScript interpreter on some benchmarks.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "DSL '11 conference proceedings.",
}

@Article{Chugh:2012:DTJ,
  author =       "Ravi Chugh and David Herman and Ranjit Jhala",
  title =        "Dependent types for {JavaScript}",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "10",
  pages =        "587--606",
  month =        oct,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2398857.2384659",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Nov 15 16:40:23 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "We present Dependent JavaScript (DJS), a statically
                 typed dialect of the imperative, object-oriented,
                 dynamic language. DJS supports the particularly
                 challenging features such as run-time type-tests,
                 higher-order functions, extensible objects, prototype
                 inheritance, and arrays through a combination of nested
                 refinement types, strong updates to the heap, and heap
                 unrolling to precisely track prototype hierarchies.
                 With our implementation of DJS, we demonstrate that the
                 type system is expressive enough to reason about a
                 variety of tricky idioms found in small examples drawn
                 from several sources, including the popular book
                 JavaScript: The Good Parts and the SunSpider benchmark
                 suite.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '12 conference proceedings.",
}

@Article{Cosentino:2012:MDR,
  author =       "Valerio Cosentino and Jordi Cabot and Patrick Albert
                 and Philippe Bauquel and Jacques Perronnet",
  title =        "A Model Driven Reverse Engineering Framework for
                 Extracting Business Rules Out of a {Java} Application",
  journal =      j-LECT-NOTES-COMP-SCI,
  volume =       "7438",
  pages =        "17--31",
  year =         "2012",
  CODEN =        "LNCSD9",
  DOI =          "https://doi.org/10.1007/978-3-642-32689-9_3",
  ISSN =         "0302-9743 (print), 1611-3349 (electronic)",
  ISSN-L =       "0302-9743",
  bibdate =      "Wed Dec 19 15:22:34 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/lncs2012g.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-642-32689-9_3/",
  acknowledgement = ack-nhfb,
  book-DOI =     "https://doi.org/10.1007/978-3-642-32689-9",
  book-URL =     "http://www.springerlink.com/content/978-3-642-32689-9",
  fjournal =     "Lecture Notes in Computer Science",
}

@Article{Cote:2012:JPS,
  author =       "Marco Cote and German Riano and Raha
                 Akhavan-Tabatabaei and Juan Fernando Perez and Andres
                 Sarmiento and Julio Goez",
  title =        "{jMarkov} package: a stochastic modeling tool",
  journal =      j-SIGMETRICS,
  volume =       "39",
  number =       "4",
  pages =        "48--48",
  month =        apr,
  year =         "2012",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/2185395.2185439",
  ISSN =         "0163-5999 (print), 1557-9484 (electronic)",
  ISSN-L =       "0163-5999",
  bibdate =      "Fri Nov 9 11:06:38 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigmetrics.bib",
  abstract =     "When analyzing real life stochastic systems in most
                 cases is easier, cheaper and more effective to use
                 analytical models rather than studying the physical
                 system or a simulation model of it. The stochastic
                 modeling is a powerful tool that helps the analysis and
                 optimization of stochastic systems. However the use of
                 stochastic modeling is not widely spread in today's
                 industries and among practitioners. This lack of
                 acceptance is caused by two main reasons the first
                 being the curse of dimensionality, which is defined by
                 the number of states required to describe a system.
                 This number grows exponentially as the size of the
                 system increases. The second reason is the lack of
                 user-friendly and efficient software packages that
                 allow the modeling of the problem without involving the
                 user with the implementation of the solution algorithms
                 to solve it. The curse of dimensionality is a constant
                 problem that has been addressed by different approaches
                 through time, but it is not intended within the scope
                 of our work; our focus is on the latter issue. We
                 propose a generic solver that enables the user to focus
                 on modeling without getting involved in the complexity
                 required by the solution methods. We design an object
                 oriented framework for stochastic modeling with four
                 components namely, jMarkov which models Markov Chains,
                 jQBD which models Quasi Birth and Death Processes,
                 jPhase which models Phase Types Distributions and jMDP
                 which models Markov Decision Processes. We concentrate
                 all our effort on creating a software that allows the
                 user to model any kind of system like a Markov Chain,
                 QBD or MDP with fairly basic knowledge of programming.
                 To this end we separate the modeling part from the
                 solution algorithms; therefore the user only needs to
                 mathematically model the problem and the software will
                 do the rest. However, we leave the package with the
                 possibility that experienced users can code their own
                 solution algorithms; this is done since the package
                 only contains the most common algorithms found in the
                 literature. The software does not use external plain
                 files like '.txt' or '.dat' written with specific
                 commands, but rather it is based on OOP (Object
                 Oriented Programming). The main advantages of it
                 include implementation in Java framework, which allows
                 the computational representation of the model to be
                 very similar to its mathematical representation such
                 that it would become natural to pass from one to
                 another. Also the program possesses the usual
                 characteristics of Java such as the use of inheritance
                 and abstraction. Finally, Java is a high level
                 computational language so the user doesn't need to be
                 concerned about technical problems.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGMETRICS Performance Evaluation Review",
  journal-URL =  "http://portal.acm.org/toc.cfm?id=J618",
}

@Article{daCosta:2012:JSL,
  author =       "Umberto Souza da Costa and Anamaria Martins Moreira
                 and Martin A. Musicante and Pl{\'a}cido A. Souza Neto",
  title =        "{JCML}: a specification language for the runtime
                 verification of {Java Card} programs",
  journal =      j-SCI-COMPUT-PROGRAM,
  volume =       "77",
  number =       "4",
  pages =        "533--550",
  day =          "1",
  month =        apr,
  year =         "2012",
  CODEN =        "SCPGD4",
  DOI =          "https://doi.org/10.1016/j.scico.2010.03.003",
  ISSN =         "0167-6423 (print), 1872-7964 (electronic)",
  ISSN-L =       "0167-6423",
  bibdate =      "Fri Feb 10 11:46:13 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/scicomputprogram.bib;
                 http://www.sciencedirect.com/science/journal/01676423",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0167642310000596",
  acknowledgement = ack-nhfb,
  fjournal =     "Science of Computer Programming",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01676423",
}

@Article{deMol:2012:GTJ,
  author =       "Maarten de Mol and Arend Rensink and James J. Hunt",
  title =        "Graph Transforming {Java} Data",
  journal =      j-LECT-NOTES-COMP-SCI,
  volume =       "7212",
  pages =        "209--223",
  year =         "2012",
  CODEN =        "LNCSD9",
  DOI =          "https://doi.org/10.1007/978-3-642-28872-2_15",
  ISSN =         "0302-9743 (print), 1611-3349 (electronic)",
  ISSN-L =       "0302-9743",
  bibdate =      "Wed Dec 19 15:26:25 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/lncs2012c.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-642-28872-2_15/",
  acknowledgement = ack-nhfb,
  book-DOI =     "https://doi.org/10.1007/978-3-642-28872-2",
  book-URL =     "http://www.springerlink.com/content/978-3-642-28872-2",
  fjournal =     "Lecture Notes in Computer Science",
}

@Article{Devietti:2012:RRC,
  author =       "Joseph Devietti and Jacob Nelson and Tom Bergan and
                 Luis Ceze and Dan Grossman",
  title =        "{RCDC}: a relaxed consistency deterministic computer",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "4",
  pages =        "67--78",
  month =        apr,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2248487.1950376",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Jun 7 08:15:03 MDT 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Providing deterministic execution significantly
                 simplifies the debugging, testing, replication, and
                 deployment of multithreaded programs. Recent work has
                 developed deterministic multiprocessor architectures as
                 well as compiler and runtime systems that enforce
                 determinism in current hardware. Such work has
                 incidentally imposed strong memory-ordering properties.
                 Historically, memory ordering has been relaxed in favor
                 of higher performance in shared memory multiprocessors
                 and, interestingly, determinism exacerbates the cost of
                 strong memory ordering. Consequently, we argue that
                 relaxed memory ordering is vital to achieving faster
                 deterministic execution. This paper introduces RCDC, a
                 deterministic multiprocessor architecture that takes
                 advantage of relaxed memory orderings to provide
                 high-performance deterministic execution with low
                 hardware complexity. RCDC has two key innovations: a
                 hybrid HW/SW approach to enforcing determinism; and a
                 new deterministic execution strategy that leverages
                 data-race-free-based memory models (e.g., the models
                 for Java and C++) to improve performance and
                 scalability without sacrificing determinism, even in
                 the presence of races. In our hybrid HW/SW approach,
                 the only hardware mechanisms required are
                 software-controlled store buffering and support for
                 precise instruction counting; we do not require
                 speculation. A runtime system uses these mechanisms to
                 enforce determinism for arbitrary programs. We evaluate
                 RCDC using PARSEC benchmarks and show that relaxing
                 memory ordering leads to performance and scalability
                 close to nondeterministic execution without requiring
                 any form of speculation. We also compare our new
                 execution strategy to one based on TSO
                 (total-store-ordering) and show that some applications
                 benefit significantly from the extra relaxation. We
                 also evaluate a software-only implementation of our new
                 deterministic execution strategy.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "ASPLOS '12 conference proceedings.",
}

@Article{Dhawan:2012:EJT,
  author =       "Mohan Dhawan and Chung-chieh Shan and Vinod
                 Ganapathy",
  title =        "Enhancing {JavaScript} with Transactions",
  journal =      j-LECT-NOTES-COMP-SCI,
  volume =       "7313",
  pages =        "383--408",
  year =         "2012",
  CODEN =        "LNCSD9",
  DOI =          "https://doi.org/10.1007/978-3-642-31057-7_18",
  ISSN =         "0302-9743 (print), 1611-3349 (electronic)",
  ISSN-L =       "0302-9743",
  bibdate =      "Wed Dec 19 15:19:51 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/lncs2012e.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-642-31057-7_18/",
  acknowledgement = ack-nhfb,
  book-DOI =     "https://doi.org/10.1007/978-3-642-31057-7",
  book-URL =     "http://www.springerlink.com/content/978-3-642-31057-7",
  fjournal =     "Lecture Notes in Computer Science",
}

@Article{DHondt:2012:ISS,
  author =       "Theo D'Hondt",
  title =        "An interpreter for server-side {HOP}",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "2",
  pages =        "1--12",
  month =        feb,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2168696.2047851",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Apr 20 17:34:09 MDT 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "HOP is a Scheme-based multi-tier programming language
                 for the Web. The client-side of a program is compiled
                 to JavaScript, while the server-side is executed by a
                 mix of natively compiled code and interpreted code. At
                 the time where HOP programs were basic scripts, the
                 performance of the server-side interpreter was not a
                 concern; an inefficient interpreter was acceptable. As
                 HOP expanded, HOP programs got larger and more complex.
                 A more efficient interpreter was necessary. This new
                 interpreter is described in this paper. It is compact,
                 its whole implementation counting no more than 2.5
                 KLOC. It is more than twice faster than the old
                 interpreter and consumes less than a third of its
                 memory. Although it cannot compete with static or JIT
                 native compilers, our experimental results show that it
                 is amongst the fastest interpreters for dynamic
                 languages.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "DSL '11 conference proceedings.",
}

@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/java2000.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 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,
  articleno =    "4",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Book{Emerick:2012:CP,
  author =       "Chas Emerick and Brian Carper and Christophe Grand",
  title =        "{Clojure} programming",
  publisher =    pub-ORA,
  address =      pub-ORA:adr,
  pages =        "xviii + 607",
  year =         "2012",
  ISBN =         "1-4493-9470-1",
  ISBN-13 =      "978-1-4493-9470-7",
  LCCN =         "QA76.73.C565 E538 2012",
  bibdate =      "Wed Nov 21 14:51:23 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/common-lisp.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/ora.bib;
                 z3950.loc.gov:7090/Voyager",
  URL =          "http://www.loc.gov/catdir/enhancements/fy1211/2012405367-b.html;
                 http://www.loc.gov/catdir/enhancements/fy1211/2012405367-d.html;
                 http://www.loc.gov/catdir/enhancements/fy1211/2012405367-t.html",
  abstract =     "This functional programming language not only lets you
                 take advantage of Java libraries, services, and other
                 JVM resources, it rivals other dynamic languages such
                 as Ruby and Python. With this comprehensive guide,
                 you'll learn Clojure fundamentals with examples that
                 relate it to languages you already know.",
  acknowledgement = ack-nhfb,
  remark =       "Practical Lisp for the Java world [from cover].",
  subject =      "Java virtual machine; Clojure (Computer program
                 language); Java (Computer program language); Functional
                 programming (Computer science)",
  tableofcontents = "Down the rabbit hole \\
                 Functional programming \\
                 Collections and data structures \\
                 Concurrency and parallelism \\
                 Macros \\
                 Datatypes and protocols \\
                 Multimethods \\
                 Organizing and building Clojure projects \\
                 Java and JVM interoperability \\
                 REPL-oriented programming \\
                 Numerics and mathematics \\
                 Design patterns \\
                 Testing \\
                 Using relational databases \\
                 Using nonrelational databases \\
                 Clojure and the Web \\
                 Deploying Clojure web applications \\
                 Choosing Clojure type definition forms wisely \\
                 Introducing Clojure into your workplace \\
                 What's next?",
}

@Article{Endrullis:2012:WEM,
  author =       "Stefan Endrullis and Andreas Thor and Erhard Rahm",
  title =        "{WETSUIT}: an efficient mashup tool for searching and
                 fusing web entities",
  journal =      j-PROC-VLDB-ENDOWMENT,
  volume =       "5",
  number =       "12",
  pages =        "1970--1973",
  month =        aug,
  year =         "2012",
  CODEN =        "????",
  ISSN =         "2150-8097",
  bibdate =      "Tue Nov 6 16:43:21 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/vldbe.bib",
  abstract =     "We demonstrate a new powerful mashup tool called
                 WETSUIT (Web EnTity Search and fUsIon Tool) to search
                 and integrate web data from diverse sources and
                 domain-specific entity search engines. WETSUIT supports
                 adaptive search strategies to query sets of relevant
                 entities with a minimum of communication overhead.
                 Mashups can be composed using a set of high-level
                 operators based on the Java-compatible language Scala.
                 The operator implementation supports a high degree of
                 parallel processing, in particular a streaming of
                 entities between all data transformation operations
                 facilitating a fast presentation of intermediate
                 results. WETSUIT has already been applied to solve
                 challenging integration tasks from different domains.",
  acknowledgement = ack-nhfb,
  fjournal =     "Proceedings of the VLDB Endowment",
}

@Article{Erdweg:2012:GLE,
  author =       "Sebastian Erdweg and Lennart C. L. Kats and Tillmann
                 Rendel and Christian K{\"a}stner and Klaus Ostermann
                 and Eelco Visser",
  title =        "Growing a language environment with editor libraries",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "3",
  pages =        "167--176",
  month =        mar,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2189751.2047891",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Jun 7 08:15:00 MDT 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Large software projects consist of code written in a
                 multitude of different (possibly domain-specific)
                 languages, which are often deeply interspersed even in
                 single files. While many proposals exist on how to
                 integrate languages semantically and syntactically, the
                 question of how to support this scenario in integrated
                 development environments (IDEs) remains open: How can
                 standard IDE services, such as syntax highlighting,
                 outlining, or reference resolving, be provided in an
                 extensible and compositional way, such that an open mix
                 of languages is supported in a single file? Based on
                 our library-based syntactic extension language for
                 Java, SugarJ, we propose to make IDEs extensible by
                 organizing editor services in editor libraries. Editor
                 libraries are libraries written in the object language,
                 SugarJ, and hence activated and composed through
                 regular import statements on a file-by-file basis. We
                 have implemented an IDE for editor libraries on top of
                 SugarJ and the Eclipse-based Spoofax language
                 workbench. We have validated editor libraries by
                 evolving this IDE into a fully-fledged and schema-aware
                 XML editor as well as an extensible Latex editor, which
                 we used for writing this paper.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "GCPE '11 conference proceedings.",
}

@Article{Exposito:2012:DSJ,
  author =       "Roberto R. Exp{\'o}sito and Guillermo L. Taboada and
                 Juan Touri{\~n}o and Ram{\'o}n Doallo",
  title =        "Design of scalable {Java} message-passing
                 communications over {InfiniBand}",
  journal =      j-J-SUPERCOMPUTING,
  volume =       "61",
  number =       "1",
  pages =        "141--165",
  month =        jul,
  year =         "2012",
  CODEN =        "JOSUED",
  ISSN =         "0920-8542 (print), 1573-0484 (electronic)",
  ISSN-L =       "0920-8542",
  bibdate =      "Fri Oct 26 07:41:32 MDT 2012",
  bibsource =    "http://springerlink.metapress.com/openurl.asp?genre=issue&issn=0920-8542&volume=61&issue=1;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/jsuper.bib",
  URL =          "http://www.springerlink.com/openurl.asp?genre=article&issn=0920-8542&volume=61&issue=1&spage=141",
  acknowledgement = ack-nhfb,
  fjournal =     "The Journal of Supercomputing",
  journal-URL =  "http://link.springer.com/journal/11227",
}

@Article{Fdez-Riverola:2012:JAF,
  author =       "F. Fdez-Riverola and D. Glez-Pe{\~n}a and H.
                 L{\'o}pez-Fern{\'a}ndez and M. Reboiro-Jato and J. R.
                 M{\'e}ndez",
  title =        "A {Java} application framework for scientific software
                 development",
  journal =      j-SPE,
  volume =       "42",
  number =       "8",
  pages =        "1015--1036",
  month =        aug,
  year =         "2012",
  CODEN =        "SPEXBL",
  DOI =          "https://doi.org/10.1002/spe.1108",
  ISSN =         "0038-0644 (print), 1097-024X (electronic)",
  ISSN-L =       "0038-0644",
  bibdate =      "Tue Nov 6 17:14:12 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/spe.bib;
                 http://www3.interscience.wiley.com/journalfinder.html",
  acknowledgement = ack-nhfb,
  fjournal =     "Software---Practice and Experience",
  journal-URL =  "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)1097-024X",
  onlinedate =   "26 Aug 2011",
}

@Article{Femminella:2012:EJC,
  author =       "Mauro Femminella and Francesco Giacinti and Gianluca
                 Reali",
  title =        "An Extended {Java} Call Control for the {Session
                 Initiation Protocol}",
  journal =      j-IEEE-MULTIMEDIA,
  volume =       "19",
  number =       "4",
  pages =        "60--71",
  month =        oct # "\slash " # dec,
  year =         "2012",
  CODEN =        "IEMUE4",
  DOI =          "https://doi.org/10.1109/MMUL.2011.58",
  ISSN =         "1070-986X (print), 1941-0166 (electronic)",
  ISSN-L =       "1070-986X",
  bibdate =      "Thu Nov 15 06:53:49 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ieeemultimedia.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE MultiMedia",
}

@Article{Fontaine:2012:VCF,
  author =       "Arnaud Fontaine and Samuel Hym and Isabelle
                 Simplot-Ryl",
  title =        "Verifiable Control Flow Policies for {Java} Bytecode",
  journal =      j-LECT-NOTES-COMP-SCI,
  volume =       "7140",
  pages =        "115--130",
  year =         "2012",
  CODEN =        "LNCSD9",
  DOI =          "https://doi.org/10.1007/978-3-642-29420-4_8",
  ISSN =         "0302-9743 (print), 1611-3349 (electronic)",
  ISSN-L =       "0302-9743",
  bibdate =      "Wed Dec 19 15:24:55 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/lncs2012b.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-642-29420-4_8/",
  acknowledgement = ack-nhfb,
  book-DOI =     "https://doi.org/10.1007/978-3-642-29420-4",
  book-URL =     "http://www.springerlink.com/content/978-3-642-29420-4",
  fjournal =     "Lecture Notes in Computer Science",
}

@Article{Funes:2012:RMC,
  author =       "Diego Funes and Junaid Haroon Siddiqui and Sarfraz
                 Khurshid",
  title =        "Ranged Model Checking",
  journal =      j-SIGSOFT,
  volume =       "37",
  number =       "6",
  pages =        "1--5",
  month =        nov,
  year =         "2012",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/2382756.2382799",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:16:18 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  abstract =     "We introduce ranged model checking, a novel technique
                 for more effective checking of Java programs using the
                 Java PathFinder (JPF) model checker. Our key insight is
                 that the order in which JPF makes non-deterministic
                 choices denes a total ordering of execution paths it
                 explores in the program it checks. Thus, two in-order
                 paths define a range for restricting the model checking
                 run by defining a start point and an end point for
                 JPF's exploration. Moreover, a given set of paths can
                 be linearly ordered to define consecutive,
                 (essentially) non-overlapping ranges that partition the
                 exploration space and can be explored separately. While
                 restricting the run of a model checker is a well-known
                 technique in model checking, the key novelty of our
                 work is conceptually to restrict the run using vertical
                 boundaries rather than the traditional approach of
                 using a horizontal boundary, i.e., the search depth
                 bound. Initial results using our prototype
                 implementation using the JPF libraries demonstrate the
                 promise ranged model checking holds.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Gadyatskaya:2012:JCA,
  author =       "Olga Gadyatskaya and Fabio Massacci and Federica Paci
                 and Sergey Stankevich",
  title =        "{Java} Card Architecture for Autonomous Yet Secure
                 Evolution of {Smart Cards} Applications",
  journal =      j-LECT-NOTES-COMP-SCI,
  volume =       "7127",
  pages =        "187--192",
  year =         "2012",
  CODEN =        "LNCSD9",
  DOI =          "https://doi.org/10.1007/978-3-642-27937-9_13",
  ISSN =         "0302-9743 (print), 1611-3349 (electronic)",
  ISSN-L =       "0302-9743",
  bibdate =      "Wed Dec 19 15:24:40 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/lncs2012b.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-642-27937-9_13/",
  acknowledgement = ack-nhfb,
  book-DOI =     "https://doi.org/10.1007/978-3-642-27937-9",
  book-URL =     "http://www.springerlink.com/content/978-3-642-27937-9",
  fjournal =     "Lecture Notes in Computer Science",
}

@Article{Gardner:2012:TPL,
  author =       "Philippa Anne Gardner and Sergio Maffeis and Gareth
                 David Smith",
  title =        "Towards a program logic for {JavaScript}",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "1",
  pages =        "31--44",
  month =        jan,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2103621.2103663",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Mar 15 18:16:55 MDT 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "JavaScript has become the most widely used language
                 for client-side web programming. The dynamic nature of
                 JavaScript makes understanding its code notoriously
                 difficult, leading to buggy programs and a lack of
                 adequate static-analysis tools. We believe that logical
                 reasoning has much to offer JavaScript: a simple
                 description of program behaviour, a clear understanding
                 of module boundaries, and the ability to verify
                 security contracts. We introduce a program logic for
                 reasoning about a broad subset of JavaScript, including
                 challenging features such as prototype inheritance and
                 `with'. We adapt ideas from separation logic to provide
                 tractable reasoning about JavaScript code: reasoning
                 about easy programs is easy; reasoning about hard
                 programs is possible. We prove a strong soundness
                 result. All libraries written in our subset and proved
                 correct with respect to their specifications will be
                 well-behaved, even when called by arbitrary JavaScript
                 code.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "POPL '12 conference proceedings.",
}

@Article{Gejibo:2012:CIE,
  author =       "Samson Gejibo and Federico Mancini",
  title =        "Challenges in Implementing an End-to-End Secure
                 Protocol for {Java ME}-Based Mobile Data Collection in
                 Low-Budget Settings",
  journal =      j-LECT-NOTES-COMP-SCI,
  volume =       "7159",
  pages =        "38--45",
  year =         "2012",
  CODEN =        "LNCSD9",
  DOI =          "https://doi.org/10.1007/978-3-642-28166-2_5",
  ISSN =         "0302-9743 (print), 1611-3349 (electronic)",
  ISSN-L =       "0302-9743",
  bibdate =      "Wed Dec 19 15:25:19 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/lncs2012b.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-642-28166-2_5/",
  acknowledgement = ack-nhfb,
  book-DOI =     "https://doi.org/10.1007/978-3-642-28166-2",
  book-URL =     "http://www.springerlink.com/content/978-3-642-28166-2",
  fjournal =     "Lecture Notes in Computer Science",
}

@Article{German:2012:MOS,
  author =       "Daniel German and Massimiliano {Di Penta}",
  title =        "A Method for Open Source License Compliance of {Java}
                 Applications",
  journal =      j-IEEE-SOFTWARE,
  volume =       "29",
  number =       "3",
  pages =        "58--63",
  month =        may # "\slash " # jun,
  year =         "2012",
  CODEN =        "IESOEG",
  DOI =          "https://doi.org/10.1109/MS.2012.50",
  ISSN =         "0740-7459 (print), 0740-7459 (electronic)",
  ISSN-L =       "0740-7459",
  bibdate =      "Thu Apr 26 17:15:53 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ieeesoft.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE Software",
  journal-URL =  "http://www.computer.org/portal/web/csdl/magazines/software",
}

@Article{Gherardi:2012:JVC,
  author =       "Luca Gherardi and Davide Brugali and Daniele Comotti",
  title =        "A {Java} vs. {C++} Performance Evaluation: a {$3$D}
                 Modeling Benchmark",
  journal =      j-LECT-NOTES-COMP-SCI,
  volume =       "7628",
  pages =        "161--172",
  year =         "2012",
  CODEN =        "LNCSD9",
  DOI =          "https://doi.org/10.1007/978-3-642-34327-8_17",
  ISSN =         "0302-9743 (print), 1611-3349 (electronic)",
  ISSN-L =       "0302-9743",
  bibdate =      "Wed Dec 19 15:26:09 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/lncs2012k.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-642-34327-8_17/",
  acknowledgement = ack-nhfb,
  book-DOI =     "https://doi.org/10.1007/978-3-642-34327-8",
  book-URL =     "http://www.springerlink.com/content/978-3-642-34327-8",
  fjournal =     "Lecture Notes in Computer Science",
}

@Article{Gil:2012:SFJ,
  author =       "Joseph Gil and Yuval Shimron",
  title =        "Smaller Footprint for {Java} Collections",
  journal =      j-LECT-NOTES-COMP-SCI,
  volume =       "7313",
  pages =        "356--382",
  year =         "2012",
  CODEN =        "LNCSD9",
  DOI =          "https://doi.org/10.1007/978-3-642-31057-7_17",
  ISSN =         "0302-9743 (print), 1611-3349 (electronic)",
  ISSN-L =       "0302-9743",
  bibdate =      "Wed Dec 19 15:19:51 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/lncs2012e.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-642-31057-7_17/",
  acknowledgement = ack-nhfb,
  book-DOI =     "https://doi.org/10.1007/978-3-642-31057-7",
  book-URL =     "http://www.springerlink.com/content/978-3-642-31057-7",
  fjournal =     "Lecture Notes in Computer Science",
}

@Article{Grossschadl:2012:EJI,
  author =       "Johann Gro{\ss}sch{\"a}dl and Dan Page and Stefan
                 Tillich",
  title =        "Efficient {Java} Implementation of Elliptic Curve
                 Cryptography for {J2ME}-Enabled Mobile Devices",
  journal =      j-LECT-NOTES-COMP-SCI,
  volume =       "7322",
  pages =        "189--207",
  year =         "2012",
  CODEN =        "LNCSD9",
  DOI =          "https://doi.org/10.1007/978-3-642-30955-7_17",
  ISSN =         "0302-9743 (print), 1611-3349 (electronic)",
  ISSN-L =       "0302-9743",
  bibdate =      "Wed Dec 19 15:20:02 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/cryptography2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/lncs2012e.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-642-30955-7_17/",
  acknowledgement = ack-nhfb,
  book-DOI =     "https://doi.org/10.1007/978-3-642-30955-7",
  book-URL =     "http://www.springerlink.com/content/978-3-642-30955-7",
  fjournal =     "Lecture Notes in Computer Science",
}

@Article{Hackett:2012:FPH,
  author =       "Brian Hackett and Shu-yu Guo",
  title =        "Fast and precise hybrid type inference for
                 {JavaScript}",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "6",
  pages =        "239--250",
  month =        jun,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2345156.2254094",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Aug 6 16:31:49 MDT 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  note =         "PLDI '12 proceedings.",
  abstract =     "JavaScript performance is often bound by its
                 dynamically typed nature. Compilers do not have access
                 to static type information, making generation of
                 efficient, type-specialized machine code difficult. We
                 seek to solve this problem by inferring types. In this
                 paper we present a hybrid type inference algorithm for
                 JavaScript based on points-to analysis. Our algorithm
                 is fast, in that it pays for itself in the
                 optimizations it enables. Our algorithm is also
                 precise, generating information that closely reflects
                 the program's actual behavior even when analyzing
                 polymorphic code, by augmenting static analysis with
                 run-time type barriers. We showcase an implementation
                 for Mozilla Firefox's JavaScript engine, demonstrating
                 both performance gains and viability. Through
                 integration with the just-in-time (JIT) compiler in
                 Firefox, we have improved performance on major
                 benchmarks and JavaScript-heavy websites by up to 50\%.
                 Inference-enabled compilation is the default
                 compilation mode as of Firefox 9.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Hasbun:2012:UTP,
  author =       "Javier E. Hasbun",
  title =        "Unifying Two Popular-but-Seemingly-Dissimilar
                 Platforms: {Matlab} and {Java}",
  journal =      j-COMPUT-SCI-ENG,
  volume =       "14",
  number =       "3",
  pages =        "6--7",
  month =        may # "\slash " # jun,
  year =         "2012",
  CODEN =        "CSENFA",
  DOI =          "https://doi.org/10.1109/MCSE.2012.58",
  ISSN =         "1521-9615 (print), 1558-366X (electronic)",
  ISSN-L =       "1521-9615",
  bibdate =      "Thu Apr 26 17:01:57 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/computscieng.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Computing in Science and Engineering",
  journal-URL =  "http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=5992",
}

@Article{Hashmi:2012:CNI,
  author =       "Atif Hashmi and Andrew Nere and James Jamal Thomas and
                 Mikko Lipasti",
  title =        "A case for neuromorphic {ISAs}",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "4",
  pages =        "145--158",
  month =        apr,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2248487.1950385",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Jun 7 08:15:03 MDT 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "The desire to create novel computing systems, paired
                 with recent advances in neuroscientific understanding
                 of the brain, has led researchers to develop
                 neuromorphic architectures that emulate the brain. To
                 date, such models are developed, trained, and deployed
                 on the same substrate. However, excessive co-dependence
                 between the substrate and the algorithm prevents
                 portability, or at the very least requires
                 reconstructing and retraining the model whenever the
                 substrate changes. This paper proposes a well-defined
                 abstraction layer --- the Neuromorphic instruction set
                 architecture, or NISA --- that separates a neural
                 application's algorithmic specification from the
                 underlying execution substrate, and describes the Aivo
                 framework, which demonstrates the concrete advantages
                 of such an abstraction layer. Aivo consists of a NISA
                 implementation for a rate-encoded neuromorphic system
                 based on the cortical column abstraction, a
                 state-of-the-art integrated development and runtime
                 environment (IDE), and various profile-based
                 optimization tools. Aivo's IDE generates code for
                 emulating cortical networks on the host CPU, multiple
                 GPGPUs, or as boolean functions. Its runtime system can
                 deploy and adaptively optimize cortical networks in a
                 manner similar to conventional just-in-time compilers
                 in managed runtime systems (e.g. Java, C\#). We
                 demonstrate the abilities of the NISA abstraction by
                 constructing a cortical network model of the mammalian
                 visual cortex, deploying on multiple execution
                 substrates, and utilizing the various optimization
                 tools we have created. For this hierarchical
                 configuration, Aivo's profiling based network
                 optimization tools reduce the memory footprint by 50\%
                 and improve the execution time by a factor of 3x on the
                 host CPU. Deploying the same network on a single GPGPU
                 results in a 30x speedup. We further demonstrate that a
                 speedup of 480x can be achieved by deploying a
                 massively scaled cortical network across three GPGPUs.
                 Finally, converting a trained hierarchical network to
                 C/C++ boolean constructs on the host CPU results in 44x
                 speedup.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "ASPLOS '12 conference proceedings.",
}

@Article{Hayashizaki:2012:IPT,
  author =       "Hiroshige Hayashizaki and Peng Wu and Hiroshi Inoue
                 and Mauricio J. Serrano and Toshio Nakatani",
  title =        "Improving the performance of trace-based systems by
                 false loop filtering",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "4",
  pages =        "405--418",
  month =        apr,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2248487.1950412",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Jun 7 08:15:03 MDT 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Trace-based compilation is a promising technique for
                 language compilers and binary translators. It offers
                 the potential to expand the compilation scopes that
                 have traditionally been limited by method boundaries.
                 Detecting repeating cyclic execution paths and
                 capturing the detected repetitions into traces is a key
                 requirement for trace selection algorithms to achieve
                 good optimization and performance with small amounts of
                 code. One important class of repetition detection is
                 cyclic-path-based repetition detection, where a cyclic
                 execution path (a path that starts and ends at the same
                 instruction address) is detected as a repeating cyclic
                 execution path. However, we found many cyclic paths
                 that are not repeating cyclic execution paths, which we
                 call false loops. A common class of false loops occurs
                 when a method is invoked from multiple call-sites. A
                 cycle is formed between two invocations of the method
                 from different call-sites, but which does not represent
                 loops or recursion. False loops can result in shorter
                 traces and smaller compilation scopes, and degrade the
                 performance. We propose false loop filtering, an
                 approach to reject false loops in the repetition
                 detection step of trace selection, and a technique
                 called false loop filtering by call-stack-comparison,
                 which rejects a cyclic path as a false loop if the call
                 stacks at the beginning and the end of the cycle are
                 different. We applied false loop filtering to our
                 trace-based Java\TM{} JIT compiler that is based on
                 IBM's J9 JVM. We found that false loop filtering
                 achieved an average improvement of 16\% and 10\% for
                 the DaCapo benchmark when applied to two baseline trace
                 selection algorithms, respectively, with up to 37\%
                 improvement for individual benchmarks. In the end, with
                 false loop filtering, our trace-based JIT achieves a
                 performance comparable to that of the method-based J9
                 JVM/JIT using the corresponding optimization level.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "ASPLOS '12 conference proceedings.",
}

@Article{Heidegger:2012:APC,
  author =       "Phillip Heidegger and Annette Bieniusa and Peter
                 Thiemann",
  title =        "Access permission contracts for scripting languages",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "1",
  pages =        "111--122",
  month =        jan,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2103621.2103671",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Mar 15 18:16:55 MDT 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "The ideal software contract fully specifies the
                 behavior of an operation. Often, in particular in the
                 context of scripting languages, a full specification
                 may be cumbersome to state and may not even be desired.
                 In such cases, a partial specification, which describes
                 selected aspects of the behavior, may be used to raise
                 the confidence in an implementation of the operation to
                 a reasonable level. We propose a novel kind of contract
                 for object-based languages that specifies the side
                 effects of an operation with access permissions. An
                 access permission contract uses sets of access paths to
                 express read and write permissions for the properties
                 of the objects accessible from the operation. We
                 specify a monitoring semantics for access permission
                 contracts and implement this semantics in a contract
                 system for JavaScript. We prove soundness and stability
                 of violation under increasing aliasing for our
                 semantics. Applications of access permission contracts
                 include enforcing modularity, test-driven development,
                 program understanding, and regression testing. With
                 respect to testing and understanding, we find that
                 adding access permissions to contracts increases the
                 effectiveness of error detection through contract
                 monitoring by 6-13\%.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "POPL '12 conference proceedings.",
}

@Article{Herranz:2012:VIP,
  author =       "{\'A}ngel Herranz and Julio Mari{\~n}o",
  title =        "A Verified Implementation of Priority Monitors in
                 {Java}",
  journal =      j-LECT-NOTES-COMP-SCI,
  volume =       "7421",
  pages =        "160--177",
  year =         "2012",
  CODEN =        "LNCSD9",
  DOI =          "https://doi.org/10.1007/978-3-642-31762-0_11",
  ISSN =         "0302-9743 (print), 1611-3349 (electronic)",
  ISSN-L =       "0302-9743",
  bibdate =      "Wed Dec 19 15:22:12 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/lncs2012g.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-642-31762-0_11/",
  acknowledgement = ack-nhfb,
  book-DOI =     "https://doi.org/10.1007/978-3-642-31762-0",
  book-URL =     "http://www.springerlink.com/content/978-3-642-31762-0",
  fjournal =     "Lecture Notes in Computer Science",
}

@Book{Horstmann:2012:JEC,
  author =       "Cay S. Horstmann",
  title =        "{Java} for everyone: compatible with {Java} 5, 6, and
                 7",
  publisher =    pub-WILEY,
  address =      pub-WILEY:adr,
  edition =      "Second",
  pages =        "xxxiii + 589",
  year =         "2012",
  ISBN =         "1-118-06331-7 (paperback)",
  ISBN-13 =      "978-1-118-06331-6 (paperback)",
  LCCN =         "QA76.73.J38 H675445 2012",
  bibdate =      "Tue May 12 16:11:39 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/prng.bib;
                 https://www.math.utah.edu/pub/tex/bib/unicode.bib;
                 z3950.loc.gov:7090/Voyager",
  abstract =     "Authoritative but accessible information on Java
                 programming fundamentals. As one of the most popular
                 programming languages in the world, Java is widely used
                 in everything from application software to web
                 applications. This helpful book escorts you through the
                 fundamentals and concepts of Java programming using a
                 first/late objects approach. Packed with extensive
                 opportunities for programming practice, Java For
                 Everyone is an ideal resource for learning all there is
                 to know about Java programming. Serves as an
                 authoritative guide on the fundamentals of Java
                 programming. Features accessible coverage compatible
                 with Java 5, 6, 7. Uses first/late objects approach and
                 provides a variety of opportunities for programming
                 practice If you're interested in learning the basics of
                 Java programming, then this is the book you need.",
  acknowledgement = ack-nhfb,
  author-dates = "1959--",
  subject =      "Java (Computer program language); COMPUTERS /
                 Programming Languages / Java.",
  tableofcontents = "1: Introduction \\
                 1.1 Computer Programs \\
                 1.2 The Anatomy of a Computer \\
                 1.3 The Java Programming Language \\
                 1.4 Becoming Familiar with Your Programming Environment
                 \\
                 1.5 Analyzing Your First Program \\
                 1.6 Errors \\
                 1.7 Problem Solving: Algorithm Design \\
                 2: Fundamental Data Types \\
                 2.1 Variables \\
                 2.2 Arithmetic \\
                 2.3 Input and Output \\
                 2.4 Problem Solving: First Do it By Hand \\
                 2.6 Strings \\
                 3: Decisions \\
                 3.1 The if Statement \\
                 3.2 Comparing Numbers and Strings \\
                 3.3 Multiple Alternatives \\
                 3.4 Nested Branches \\
                 3.5 Problem Solving: Flowcharts \\
                 3.6 Problem Solving: Test Cases \\
                 3.7 Boolean Variables and Operators \\
                 3.8 Application: Input Validation \\
                 4: Loops \\
                 4.1 The while Loop \\
                 4.2 Problem Solving: Hand-Tracing \\
                 4.3 The for Loop \\
                 4.4 The do Loop \\
                 4.5 Application: Processing Sentinel Values \\
                 4.6 Problem Solving: Storyboards \\
                 4.7 Common Loop Algorithms \\
                 4.8 Nested Loops \\
                 4.9 Application: Random Numbers and Simulations \\
                 5: Methods \\
                 5.1 Methods as Black Boxes \\
                 5.2 Implementing Methods \\
                 5.3 Parameter Passing \\
                 5.4 Return Values \\
                 5.5 Methods Without Return Values \\
                 5.6 Problem Solving: Reusable Functions \\
                 5.7 Problem Solving: Stepwise Refinement \\
                 5.8 Variable Scope \\
                 5.9 Recursive Methods (Optional) \\
                 6: Arrays and Array Lists \\
                 6.1 Arrays \\
                 6.2 The Enhanced for Loop \\
                 6.3 Common Array Algorithms \\
                 6.4 Using Arrays with Methods \\
                 6.5 Problem Solving: Adapting Algorithms \\
                 6.6 Problem Solving: Discovering Algorithms by
                 Manipulating Physical Objects \\
                 6.7 Two-Dimensional Arrays \\
                 6.8 Array Lists \\
                 7: Input/Output and Exception Handling \\
                 7.1 Reading and Writing Text Files \\
                 7.2 Processing Text Input \\
                 7.3 Command Line Arguments \\
                 7.4 Checked and Unchecked Exceptions \\
                 7.5 Catching Exceptions \\
                 7.6 The finally Clause \\
                 7.7 Application: Handling Input Errors \\
                 8: Object and Classes \\
                 8.1 Object-Oriented Programming \\
                 8.2 Implementing a Simple Class \\
                 8.3 Specifying the Public Interface of a Class \\
                 8.4 Designing the Data Representation \\
                 8.5 Problem Solving: Patterns for Representing Behavior
                 \\
                 8.6 Implementing Instance Methods \\
                 8.7 Constructors \\
                 8.8 Problem Solving: Tracing Objects \\
                 8.9 Testing a Class \\
                 8.10 Object References \\
                 8.11 Static Variables and Methods \\
                 9: Inheritance \\
                 9.1 Inheritance Hierarchies \\
                 9.2 Implementing Subclasses \\
                 9.3 Overriding Methods \\
                 9.4 Polymorphism \\
                 9.5 Object: The Cosmic Superclass \\
                 9.6 Interface Types \\
                 10: Graphical User Interfaces \\
                 10.1 Frame Windows \\
                 10.2 Events and Event Handling \\
                 10.3 Using Inheritance to Customize Frames \\
                 10.4 Building Applications with Buttons \\
                 10.5 Using Inner Classes for Listeners \\
                 10.6 Processing Text Input \\
                 10.7 Text Areas Web chapters \\
                 11: Advanced Graphical User Interfaces \\
                 11.1 Layout Management \\
                 11.2 Choices \\
                 11.3 Menus \\
                 11.4 Exploring the Swing Documentation \\
                 11.5 Drawing on a Component \\
                 11.6 Using Timer Events for Animations \\
                 11.7 Mouse Events \\
                 12: Object-Oriented Design \\
                 12.1 The Software Life Cycle \\
                 12.2 Discovering Classes \\
                 12.3 Relationships Between Classes \\
                 12.4 Cohesion and Coupling \\
                 12.5 Side Effects \\
                 12.5 Abstract Classes \\
                 12.6 Packages \\
                 12.7 Application: Printing an Invoice \\
                 12.8 Application: An Automatic Teller Machine \\
                 13: Recursion \\
                 13.1 Triangle Numbers \\
                 13.2. Thinking Recursively \\
                 13.3 Recursive Helper Methods \\
                 13.4 The Efficiency of Recursion \\
                 13.5 Permutations \\
                 13.6 Mutual Recursions \\
                 13.7 Backtracking \\
                 14: Sorting and Searching \\
                 14.1 Selection Sort \\
                 14.2 Profiling the Selection Sort Algorithm \\
                 14.3 Analyzing the Performance of the Selection Sort
                 Algorithm \\
                 14.4 Merge Sort \\
                 14.5 Analyzing the Merge Sort Algorithm \\
                 14.6 Searching \\
                 14.7 Binary Search \\
                 14.8 Sorting Real Data \\
                 15: The Java Collections Framework \\
                 15.1. An Overview of the Collections Framework \\
                 15.2. Linked Lists \\
                 15.3. Stacks, Queues, and Priority Queues \\
                 15.4. Sets \\
                 15.5. Maps \\
                 Appendices \\
                 Appendix A: The Basic Latin and Latin-1 Subsets of
                 Unicode \\
                 Appendix B: Java Operator Summary \\
                 Appendix C: Java Reserved Word Summary \\
                 Appendix D: The Java Library \\
                 Appendix E: Java Syntax Summary (Online only) \\
                 Appendix F: HTML Summary (Online only) \\
                 Appendix G: Tool Summary (Online only) \\
                 Appendix H: Javadoc Summary (Online only)",
}

@Article{Hosking:2012:CHL,
  author =       "Tony Hosking",
  title =        "Compiling a high-level language for {GPUs}: (via
                 language support for architectures and compilers)",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "6",
  pages =        "1--12",
  month =        jun,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2345156.2254066",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Aug 6 16:31:49 MDT 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  note =         "PLDI '12 proceedings.",
  abstract =     "Languages such as OpenCL and CUDA offer a standard
                 interface for general-purpose programming of GPUs.
                 However, with these languages, programmers must
                 explicitly manage numerous low-level details involving
                 communication and synchronization. This burden makes
                 programming GPUs difficult and error-prone, rendering
                 these powerful devices inaccessible to most
                 programmers. We desire a higher-level programming model
                 that makes GPUs more accessible while also effectively
                 exploiting their computational power. This paper
                 presents features of Lime, a new Java-compatible
                 language targeting heterogeneous systems, that allow an
                 optimizing compiler to generate high quality GPU code.
                 The key insight is that the language type system
                 enforces isolation and immutability invariants that
                 allow the compiler to optimize for a GPU without heroic
                 compiler analysis. Our compiler attains GPU speedups
                 between 75\% and 140\% of the performance of native
                 OpenCL code.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Huang:2012:RRC,
  author =       "Wei Huang and Ana Milanova and Werner Dietl and
                 Michael D. Ernst",
  title =        "{Reim \& ReImInfer}: checking and inference of
                 reference immutability and method purity",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "10",
  pages =        "879--896",
  month =        oct,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2398857.2384680",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Nov 15 16:40:23 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Reference immutability ensures that a reference is not
                 used to modify the referenced object, and enables the
                 safe sharing of object structures. A pure method does
                 not cause side-effects on the objects that existed in
                 the pre-state of the method execution. Checking and
                 inference of reference immutability and method purity
                 enables a variety of program analyses and
                 optimizations. We present ReIm, a type system for
                 reference immutability, and ReImInfer, a corresponding
                 type inference analysis. The type system is concise and
                 context-sensitive. The type inference analysis is
                 precise and scalable, and requires no manual
                 annotations. In addition, we present a novel
                 application of the reference immutability type system:
                 method purity inference. To support our theoretical
                 results, we implemented the type system and the type
                 inference analysis for Java. We include a type checker
                 to verify the correctness of the inference result.
                 Empirical results on Java applications and libraries of
                 up to 348kLOC show that our approach achieves both
                 scalability and precision.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '12 conference proceedings.",
}

@Article{hunEom:2012:DDP,
  author =       "Yong hun Eom and Stephen Yang and James C. Jenista and
                 Brian Demsky",
  title =        "{DOJ}: dynamically parallelizing object-oriented
                 programs",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "8",
  pages =        "85--96",
  month =        aug,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2370036.2145828",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Wed Sep 12 12:11:57 MDT 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "PPOPP '12 conference proceedings.",
  abstract =     "We present Dynamic Out-of-Order Java (DOJ), a dynamic
                 parallelization approach. In DOJ, a developer annotates
                 code blocks as tasks to decouple these blocks from the
                 parent execution thread. The DOJ compiler then analyzes
                 the code to generate heap examiners that ensure the
                 parallel execution preserves the behavior of the
                 original sequential program. Heap examiners dynamically
                 extract heap dependences between code blocks and
                 determine when it is safe to execute a code block. We
                 have implemented DOJ and evaluated it on twelve
                 benchmarks. We achieved an average compilation speedup
                 of 31.15 times over OoOJava and an average execution
                 speedup of 12.73 times over sequential versions of the
                 benchmarks.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{hunEom:2012:SSJ,
  author =       "Yong hun Eom and Brian Demsky",
  title =        "Self-stabilizing {Java}",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "6",
  pages =        "287--298",
  month =        jun,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2345156.2254099",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Aug 6 16:31:49 MDT 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  note =         "PLDI '12 proceedings.",
  abstract =     "Self-stabilizing programs automatically recover from
                 state corruption caused by software bugs and other
                 sources to reach the correct state. A number of
                 applications are inherently self-stabilizing---such
                 programs typically overwrite all non-constant data with
                 new input data. We present a type system and static
                 analyses that together check whether a program is
                 self-stabilizing. We combine this with a code
                 generation strategy that ensures that a program
                 continues executing long enough to self-stabilize. Our
                 experience using SJava indicates that (1) SJava
                 annotations are easy to write once one understands a
                 program and (2) SJava successfully checked that several
                 benchmarks were self-stabilizing.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Book{Hunt:2012:JP,
  author =       "Charlie Hunt and Binu John",
  title =        "{Java} Performance",
  publisher =    pub-AW,
  address =      pub-AW,
  pages =        "xxi + 693",
  year =         "2012",
  ISBN =         "0-13-714252-8 (paperback)",
  ISBN-13 =      "978-0-13-714252-1 (paperback)",
  LCCN =         "QA76.73.J38 H845 2012",
  bibdate =      "Thu Dec 4 13:30:51 MST 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 z3950.loc.gov:7090/Voyager",
  series =       "The Java series",
  acknowledgement = ack-nhfb,
  author-dates = "1962--",
  subject =      "Java (Computer program language); Computer
                 programming",
  tableofcontents = "Strategies, approaches, and methodologies \\
                 Operating system performance monitoring \\
                 JVM overview \\
                 JVM performance monitoring \\
                 Java application profiling \\
                 Java application profiling tips and tricks \\
                 Tuning the JVM, step by step \\
                 Benchmarking Java applications \\
                 Benchmarking multi-tiered applications \\
                 Web application performance \\
                 Web services performance \\
                 Java persistence and enterprise Java Beans
                 performance",
}

@Article{Inoue:2012:AML,
  author =       "Hiroshi Inoue and Hiroshige Hayashizaki and Peng Wu
                 and Toshio Nakatani",
  title =        "Adaptive multi-level compilation in a trace-based
                 {Java JIT} compiler",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "10",
  pages =        "179--194",
  month =        oct,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2398857.2384630",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Nov 15 16:40:23 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "This paper describes our multi-level compilation
                 techniques implemented in a trace-based Java JIT
                 compiler (trace-JIT). Like existing multi-level
                 compilation for method-based compilers, we start JIT
                 compilation with a small compilation scope and a low
                 optimization level so the program can start running
                 quickly. Then we identify hot paths with a timer-based
                 sampling profiler, generate long traces that capture
                 the hot paths, and recompile them with a high
                 optimization level to improve the peak performance. A
                 key to high performance is selecting long traces that
                 effectively capture the entire hot paths for upgrade
                 recompilations. To do this, we introduce a new
                 technique to generate a directed graph representing the
                 control flow, a TTgraph, and use the TTgraph in the
                 trace selection engine to efficiently select long
                 traces. We show that our multi-level compilation
                 improves the peak performance of programs by up to
                 58.5\% and 22.2\% on average compared to compiling all
                 of the traces only at a low optimization level.
                 Comparing the performance with our multi-level
                 compilation to the performance when compiling all of
                 the traces at a high optimization level, our technique
                 can reduce the startup times of programs by up to
                 61.1\% and 31.3\% on average without significant
                 reduction in the peak performance. Our results show
                 that our adaptive multi-level compilation can balance
                 the peak performance and startup time by taking
                 advantage of different optimization levels.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '12 conference proceedings.",
}

@Article{Inoue:2012:ISC,
  author =       "Hiroshi Inoue and Toshio Nakatani",
  title =        "Identifying the sources of cache misses in {Java}
                 programs without relying on hardware counters",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "11",
  pages =        "133--142",
  month =        nov,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2426642.2259014",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Jan 10 08:55:30 MST 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  note =         "ISMM '12 conference proceedings.",
  abstract =     "Cache miss stalls are one of the major sources of
                 performance bottlenecks for multicore processors. A
                 Hardware Performance Monitor (HPM) in the processor is
                 useful for locating the cache misses, but is rarely
                 used in the real world for various reasons. It would be
                 better to find a simple approach to locate the sources
                 of cache misses and apply runtime optimizations without
                 relying on an HPM. This paper shows that pointer
                 dereferencing in hot loops is a major source of cache
                 misses in Java programs. Based on this observation, we
                 devised a new approach to identify the instructions and
                 objects that cause frequent cache misses. Our heuristic
                 technique effectively identifies the majority of the
                 cache misses in typical Java programs by matching the
                 hot loops to simple idiomatic code patterns. On
                 average, our technique selected only 2.8\% of the load
                 and store instructions generated by the JIT compiler
                 and these instructions accounted for 47\% of the L1D
                 cache misses and 49\% of the L2 cache misses caused by
                 the JIT-compiled code. To prove the effectiveness of
                 our technique in compiler optimizations, we prototyped
                 object placement optimizations, which align objects in
                 cache lines or collocate paired objects in the same
                 cache line to reduce cache misses. For comparison, we
                 also implemented the same optimizations based on the
                 accurate information obtained from the HPM. Our results
                 showed that our heuristic approach was as effective as
                 the HPM-based approach and achieved comparable
                 performance improvements in the {\tt SPECjbb2005} and
                 {\tt SPECpower\_ssj2008} benchmark programs.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@InProceedings{Islam:2012:HPR,
  author =       "N. S. Islam and M. W. Rahman and J. Jose and R.
                 Rajachandrasekar and H. Wang and H. Subramoni and C.
                 Murthy and D. K. Panda",
  title =        "High performance {RDMA}-based design of {HDFS} over
                 {InfiniBand}",
  crossref =     "Hollingsworth:2012:SPI",
  pages =        "35:1--35:12",
  year =         "2012",
  bibdate =      "Thu Nov 15 07:38:35 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/supercomputing2012.bib",
  URL =          "http://conferences.computer.org/sc/2012/papers/1000a058.pdf",
  abstract =     "Hadoop Distributed File System (HDFS) acts as the
                 primary storage of Hadoop and has been adopted by
                 reputed organizations (Facebook, Yahoo! etc.) due to
                 its portability and fault-tolerance. The existing
                 implementation of HDFS uses Java-socket interface for
                 communication which delivers suboptimal performance in
                 terms of latency and throughput. For data-intensive
                 applications, network performance becomes key component
                 as the amount of data being stored and replicated to
                 HDFS increases. In this paper, we present a novel
                 design of HDFS using Remote Direct Memory Access (RDMA)
                 over InfiniBand via JNI interfaces. Experimental
                 results show that, for 5GB HDFS file writes, the new
                 design reduces the communication time by 87\% and 30\%
                 over 1Gigabit Ethernet (1GigE) and IP-over-InfiniBand
                 (IPoIB), respectively, on QDR platform (32Gbps). For
                 HBase, the Put operation performance is improved by
                 26\% with our design. To the best of our knowledge,
                 this is the first design of HDFS over InfiniBand
                 networks.",
  acknowledgement = ack-nhfb,
  articleno =    "35",
}

@Article{Jara:2012:NVJ,
  author =       "Carlos A. Jara and Francisco Esquembre and Wolfgang
                 Christian and Francisco A. Candelas and Fernando Torres
                 and Sebasti{\'a}n Dormido",
  title =        "A new {$3$D} visualization {Java} framework based on
                 physics principles",
  journal =      j-COMP-PHYS-COMM,
  volume =       "183",
  number =       "2",
  pages =        "231--244",
  month =        feb,
  year =         "2012",
  CODEN =        "CPHCBZ",
  DOI =          "https://doi.org/10.1016/j.cpc.2011.08.007",
  ISSN =         "0010-4655 (print), 1879-2944 (electronic)",
  ISSN-L =       "0010-4655",
  bibdate =      "Sat Feb 11 10:11:01 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/compphyscomm2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0010465511002797",
  acknowledgement = ack-nhfb,
  fjournal =     "Computer Physics Communications",
  journal-URL =  "http://www.sciencedirect.com/science/journal/00104655",
}

@Book{Jendrock:2012:JET,
  author =       "Eric Jendrock",
  title =        "The {Java EE 6} Tutorial: advanced topics",
  volume =       "II",
  publisher =    pub-AW,
  address =      pub-AW,
  edition =      "Fourth",
  pages =        "????",
  year =         "2012",
  ISBN =         "0-13-708186-3 (paperback)",
  ISBN-13 =      "978-0-13-708186-8 (paperback)",
  LCCN =         "????",
  bibdate =      "Mon Jan 28 12:24:06 MST 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 z3950.loc.gov:7090/Voyager",
  acknowledgement = ack-nhfb,
}

@Article{Ji:2012:PKP,
  author =       "Ran Ji and Richard Bubel",
  title =        "{PE-KeY}: a Partial Evaluator for {Java} Programs",
  journal =      j-LECT-NOTES-COMP-SCI,
  volume =       "7321",
  pages =        "283--295",
  year =         "2012",
  CODEN =        "LNCSD9",
  DOI =          "https://doi.org/10.1007/978-3-642-30729-4_20",
  ISSN =         "0302-9743 (print), 1611-3349 (electronic)",
  ISSN-L =       "0302-9743",
  bibdate =      "Wed Dec 19 15:20:00 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/lncs2012e.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-642-30729-4_20/",
  acknowledgement = ack-nhfb,
  book-DOI =     "https://doi.org/10.1007/978-3-642-30729-4",
  book-URL =     "http://www.springerlink.com/content/978-3-642-30729-4",
  fjournal =     "Lecture Notes in Computer Science",
}

@Article{Jin:2012:JMM,
  author =       "Huafeng Jin and Tuba Yavuz-Kahveci and Beverly A.
                 Sanders",
  title =        "{Java} Memory Model-Aware Model Checking",
  journal =      j-LECT-NOTES-COMP-SCI,
  volume =       "7214",
  pages =        "220--236",
  year =         "2012",
  CODEN =        "LNCSD9",
  DOI =          "https://doi.org/10.1007/978-3-642-28756-5_16",
  ISSN =         "0302-9743 (print), 1611-3349 (electronic)",
  ISSN-L =       "0302-9743",
  bibdate =      "Wed Dec 19 15:26:28 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/lncs2012c.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-642-28756-5_16/",
  acknowledgement = ack-nhfb,
  book-DOI =     "https://doi.org/10.1007/978-3-642-28756-5",
  book-URL =     "http://www.springerlink.com/content/978-3-642-28756-5",
  fjournal =     "Lecture Notes in Computer Science",
}

@Article{Johnsen:2012:SLM,
  author =       "Einar Broch Johnsen and Thi Mai Thuong Tran and Olaf
                 Owe",
  title =        "Safe Locking for Multi-threaded {Java}",
  journal =      j-LECT-NOTES-COMP-SCI,
  volume =       "7141",
  pages =        "158--173",
  year =         "2012",
  CODEN =        "LNCSD9",
  DOI =          "https://doi.org/10.1007/978-3-642-29320-7_11",
  ISSN =         "0302-9743 (print), 1611-3349 (electronic)",
  ISSN-L =       "0302-9743",
  bibdate =      "Wed Dec 19 15:24:56 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/lncs2012b.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-642-29320-7_11/",
  acknowledgement = ack-nhfb,
  book-DOI =     "https://doi.org/10.1007/978-3-642-29320-7",
  book-URL =     "http://www.springerlink.com/content/978-3-642-29320-7",
  fjournal =     "Lecture Notes in Computer Science",
}

@Book{Juneau:2012:JRP,
  author =       "Josh Juneau and others",
  title =        "{Java 7} recipes: a problem-solution approach",
  publisher =    pub-APRESS,
  address =      pub-APRESS:adr,
  pages =        "xxii + 848",
  year =         "2012",
  ISBN =         "1-4302-4056-3 (paperback)",
  ISBN-13 =      "978-1-4302-4056-3 (paperback)",
  LCCN =         "QA76.73.J38 J35946 2012",
  bibdate =      "Tue May 12 16:05:50 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/unicode.bib;
                 z3950.loc.gov:7090/Voyager",
  acknowledgement = ack-nhfb,
  subject =      "Java (Computer program language); Application
                 software; Development",
  tableofcontents = "Getting started with Java 7 \\
                 Strings \\
                 Numbers and dates \\
                 Data structures, conditionals, and iteration \\
                 Input and output \\
                 Exceptions and logging \\
                 Object-oriented Java \\
                 Concurrency \\
                 Debugging and unit testing \\
                 Unicode, internationalization, and currency codes \\
                 Working with databases \\
                 Java 2D graphics \\
                 Java 3D \\
                 Swing API \\
                 JavaFX fundamentals \\
                 Graphics with JavaFX \\
                 Media with JavaFX \\
                 Working with servlets and applets \\
                 Intro to Android \\
                 JavaFX on the web \\
                 E-mail \\
                 XML processing \\
                 Networking",
}

@Article{Jung:2012:EJA,
  author =       "Dong-Heon Jung and Soo-Mook Moon and Sung-Hwan Bae",
  title =        "Evaluation of a {Java} Ahead-of-Time Compiler for
                 Embedded Systems",
  journal =      j-COMP-J,
  volume =       "55",
  number =       "2",
  pages =        "232--252",
  month =        feb,
  year =         "2012",
  CODEN =        "CMPJA6",
  DOI =          "https://doi.org/10.1093/comjnl/bxr100",
  ISSN =         "0010-4620 (print), 1460-2067 (electronic)",
  ISSN-L =       "0010-4620",
  bibdate =      "Thu Feb 2 09:12:17 MST 2012",
  bibsource =    "http://comjnl.oxfordjournals.org/content/55/2.toc;
                 https://www.math.utah.edu/pub/tex/bib/compj2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://comjnl.oxfordjournals.org/content/55/2/232.full.pdf+html",
  acknowledgement = ack-nhfb,
  fjournal =     "Computer Journal",
  journal-URL =  "http://comjnl.oxfordjournals.org/",
  onlinedate =   "October 5, 2011",
}

@Article{Kang:2012:FSJ,
  author =       "Seonghoon Kang and Sukyoung Ryu",
  title =        "Formal specification of a {JavaScript} module system",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "10",
  pages =        "621--638",
  month =        oct,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2398857.2384661",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Nov 15 16:40:23 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "The JavaScript programming language, originally
                 developed as a simple scripting language, is now the
                 language of choice for web applications. All the top
                 100 sites on the web use JavaScript and its use outside
                 web pages is rapidly growing. However, JavaScript is
                 not yet ready for programming in the large: it does not
                 support a module system. Lack of namespaces introduces
                 module patterns, and makes it difficult to use multiple
                 JavaScript frameworks together. In this paper, we
                 propose a formal specification of a JavaScript module
                 system. A module system for JavaScript will allow safe
                 and incremental development of JavaScript web
                 applications. While the next version of the JavaScript
                 standard proposes a module system, it informally
                 describes its design in prose. We formally specify a
                 module system as an extension to the existing
                 JavaScript language, and rigorously describe its
                 semantics via desugaring to LambdaJS, a prior core
                 calculus for JavaScript. We implement the desugaring
                 process and show its faithfulness using real-world test
                 suites. Finally, we define a set of properties for
                 valid JavaScript programs using modules and formally
                 prove that the proposed module system satisfies the
                 validity properties.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '12 conference proceedings.",
}

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

@Article{Khyzha:2012:AP,
  author =       "Artem Khyzha and Pavel Par{\'\i}zek and Corina S.
                 P{\u{a}}s{\u{a}}reanu",
  title =        "Abstract pathfinder",
  journal =      j-SIGSOFT,
  volume =       "37",
  number =       "6",
  pages =        "1--5",
  month =        nov,
  year =         "2012",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/2382756.2382794",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:16:18 MDT 2018",
  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/sigsoft2010.bib",
  abstract =     "We present Abstract Pathfinder, an extension to the
                 Java Pathfinder (JPF) verification tool-set that
                 supports data abstraction to reduce the large data
                 domains of a Java program to small, finite abstract
                 domains, making the program more amenable to
                 verification. We use data abstraction to compute an
                 over-approximation of the original program in such a
                 way that if a (safety) property is true in the
                 abstracted program the property is also true in the
                 original program. Our approach enhances JPF with an
                 abstract interpreter and abstract state-matching
                 mechanisms, together with a library of abstractions
                 from which the user can pick which abstractions to use
                 for a particular application. We discuss the details of
                 our implementation together with some preliminary
                 experiments with analyzing multi-threaded Java
                 programs, where Abstract Pathfinder achieves
                 significant time and memory savings as compared with
                 plain JPF.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Kossakowski:2012:JED,
  author =       "Grzegorz Kossakowski and Nada Amin and Tiark Rompf and
                 Martin Odersky",
  title =        "{JavaScript} as an Embedded {DSL}",
  journal =      j-LECT-NOTES-COMP-SCI,
  volume =       "7313",
  pages =        "409--434",
  year =         "2012",
  CODEN =        "LNCSD9",
  DOI =          "https://doi.org/10.1007/978-3-642-31057-7_19",
  ISSN =         "0302-9743 (print), 1611-3349 (electronic)",
  ISSN-L =       "0302-9743",
  bibdate =      "Wed Dec 19 15:19:51 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/lncs2012e.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-642-31057-7_19/",
  acknowledgement = ack-nhfb,
  book-DOI =     "https://doi.org/10.1007/978-3-642-31057-7",
  book-URL =     "http://www.springerlink.com/content/978-3-642-31057-7",
  fjournal =     "Lecture Notes in Computer Science",
}

@Article{Kouneli:2012:MKD,
  author =       "Aggeliki Kouneli and Georgia Solomou and Christos
                 Pierrakeas and Achilles Kameas",
  title =        "Modeling the Knowledge Domain of the {Java}
                 Programming Language as an Ontology",
  journal =      j-LECT-NOTES-COMP-SCI,
  volume =       "7558",
  pages =        "152--159",
  year =         "2012",
  CODEN =        "LNCSD9",
  DOI =          "https://doi.org/10.1007/978-3-642-33642-3_16",
  ISSN =         "0302-9743 (print), 1611-3349 (electronic)",
  ISSN-L =       "0302-9743",
  bibdate =      "Wed Dec 19 15:24:55 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/lncs2012j.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-642-33642-3_16/",
  acknowledgement = ack-nhfb,
  book-DOI =     "https://doi.org/10.1007/978-3-642-33642-3",
  book-URL =     "http://www.springerlink.com/content/978-3-642-33642-3",
  fjournal =     "Lecture Notes in Computer Science",
}

@Article{Krishnamurthi:2012:SAJ,
  author =       "Shriram Krishnamurthi",
  title =        "Semantics and Analyses for {JavaScript} and the
                 {Web}",
  journal =      j-LECT-NOTES-COMP-SCI,
  volume =       "7460",
  pages =        "4--4",
  year =         "2012",
  CODEN =        "LNCSD9",
  DOI =          "https://doi.org/10.1007/978-3-642-33125-1_3",
  ISSN =         "0302-9743 (print), 1611-3349 (electronic)",
  ISSN-L =       "0302-9743",
  bibdate =      "Wed Dec 19 15:23:03 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/lncs2012h.bib",
  URL =          "http://link.springer.com/accesspage/chapter/10.1007/978-3-642-33125-1_3",
  acknowledgement = ack-nhfb,
  book-DOI =     "https://doi.org/10.1007/978-3-642-33125-1",
  book-URL =     "http://www.springerlink.com/content/978-3-642-33125-1",
  fjournal =     "Lecture Notes in Computer Science",
}

@Article{Krishnaveni:2012:HOJ,
  author =       "R. Krishnaveni and C. Chellappan and R. Dhanalakshmi",
  title =        "Hybrid Obfuscated {Javascript} Strength Analysis
                 System for Detection of Malicious Websites",
  journal =      j-LECT-NOTES-COMP-SCI,
  volume =       "7513",
  pages =        "129--137",
  year =         "2012",
  CODEN =        "LNCSD9",
  DOI =          "https://doi.org/10.1007/978-3-642-35606-3_15",
  ISSN =         "0302-9743 (print), 1611-3349 (electronic)",
  ISSN-L =       "0302-9743",
  bibdate =      "Wed Dec 19 15:24:06 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/lncs2012i.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-642-35606-3_15/",
  acknowledgement = ack-nhfb,
  book-DOI =     "https://doi.org/10.1007/978-3-642-35606-3",
  book-URL =     "http://www.springerlink.com/content/978-3-642-35606-3",
  fjournal =     "Lecture Notes in Computer Science",
}

@Article{Kulkarni:2012:MCO,
  author =       "Sameer Kulkarni and John Cavazos",
  title =        "Mitigating the compiler optimization phase-ordering
                 problem using machine learning",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "10",
  pages =        "147--162",
  month =        oct,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2398857.2384628",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Nov 15 16:40:23 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Today's compilers have a plethora of optimizations to
                 choose from, and the correct choice of optimizations
                 can have a significant impact on the performance of the
                 code being optimized. Furthermore, choosing the correct
                 order in which to apply those optimizations has been a
                 long standing problem in compilation research. Each of
                 these optimizations interacts with the code and in turn
                 with all other optimizations in complicated ways.
                 Traditional compilers typically apply the same set of
                 optimization in a fixed order to all functions in a
                 program, without regard the code being optimized.
                 Understanding the interactions of optimizations is very
                 important in determining a good solution to the
                 phase-ordering problem. This paper develops a new
                 approach that automatically selects good optimization
                 orderings on a per method basis within a dynamic
                 compiler. Our approach formulates the phase-ordering
                 problem as a Markov process and uses a characterization
                 of the current state of the code being optimized to
                 creating a better solution to the phase ordering
                 problem. Our technique uses neuro-evolution to
                 construct an artificial neural network that is capable
                 of predicting beneficial optimization ordering for a
                 piece of code that is being optimized. We implemented
                 our technique in Jikes RVM and achieved significant
                 improvements on a set of standard Java benchmarks over
                 a well-engineered fixed order.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '12 conference proceedings.",
}

@Article{Kumar:2012:WSB,
  author =       "Vivek Kumar and Daniel Frampton and Stephen M.
                 Blackburn and David Grove and Olivier Tardieu",
  title =        "Work-stealing without the baggage",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "10",
  pages =        "297--314",
  month =        oct,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2398857.2384639",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Nov 15 16:40:23 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Work-stealing is a promising approach for effectively
                 exploiting software parallelism on parallel hardware. A
                 programmer who uses work-stealing explicitly identifies
                 potential parallelism and the runtime then schedules
                 work, keeping otherwise idle hardware busy while
                 relieving overloaded hardware of its burden. Prior work
                 has demonstrated that work-stealing is very effective
                 in practice. However, work-stealing comes with a
                 substantial overhead: as much as 2x to 12x slowdown
                 over orthodox sequential code. In this paper we
                 identify the key sources of overhead in work-stealing
                 schedulers and present two significant refinements to
                 their implementation. We evaluate our work-stealing
                 designs using a range of benchmarks, four different
                 work-stealing implementations, including the popular
                 fork-join framework, and a range of architectures. On
                 these benchmarks, compared to orthodox sequential Java,
                 our fastest design has an overhead of just 15\%. By
                 contrast, fork-join has a 2.3x overhead and the
                 previous implementation of the system we use has an
                 overhead of 4.1x. These results and our insight into
                 the sources of overhead for work-stealing
                 implementations give further hope to an already
                 promising technique for exploiting increasingly
                 available hardware parallelism.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '12 conference proceedings.",
}

@Article{Laskowski:2012:DJP,
  author =       "Eryk Laskowski and Marek Tudruj and Ivanoe {De Falco}
                 and Umberto Scafuri and Ernesto Tarantino",
  title =        "Distributed {Java} Programs Initial Mapping Based on
                 Extremal Optimization",
  journal =      j-LECT-NOTES-COMP-SCI,
  volume =       "7133",
  pages =        "75--85",
  year =         "2012",
  CODEN =        "LNCSD9",
  DOI =          "https://doi.org/10.1007/978-3-642-28151-8_8",
  ISSN =         "0302-9743 (print), 1611-3349 (electronic)",
  ISSN-L =       "0302-9743",
  bibdate =      "Wed Dec 19 15:24:46 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/lncs2012b.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-642-28151-8_8/",
  acknowledgement = ack-nhfb,
  book-DOI =     "https://doi.org/10.1007/978-3-642-28151-8",
  book-URL =     "http://www.springerlink.com/content/978-3-642-28151-8",
  fjournal =     "Lecture Notes in Computer Science",
}

@Article{Lin:2012:UKT,
  author =       "Yi Lin and Stephen M. Blackburn and Daniel Frampton",
  title =        "Unpicking the knot: teasing apart {VM}\slash
                 application interdependencies",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "7",
  pages =        "181--190",
  month =        jul,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2365864.2151048",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Sep 6 10:01:03 MDT 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "VEE '12 conference proceedings.",
  abstract =     "Flexible and efficient runtime design requires an
                 understanding of the dependencies among the components
                 internal to the runtime and those between the
                 application and the runtime. These dependencies are
                 frequently unclear. This problem exists in all runtime
                 design, and is most vivid in a metacircular runtime ---
                 one that is implemented in terms of itself.
                 Metacircularity blurs boundaries between application
                 and runtime implementation, making it harder to
                 understand and make guarantees about overall system
                 behavior, affecting isolation, security, and resource
                 management, as well as reducing opportunities for
                 optimization. Our goal is to shed new light on VM
                 interdependencies, helping all VM designers understand
                 these dependencies and thereby engineer better
                 runtimes. We explore these issues in the context of a
                 high-performance Java-in-Java virtual machine. Our
                 approach is to identify and instrument transition
                 points into and within the runtime, which allows us to
                 establish a dynamic execution context. Our
                 contributions are: (1) implementing and measuring a
                 system that dynamically maintains execution context
                 with very low overhead, (2) demonstrating that such a
                 framework can be used to improve the software
                 engineering of an existing runtime, and (3) analyzing
                 the behavior and runtime characteristics of our runtime
                 across a wide range of benchmarks. Our solution
                 provides clarity about execution state and allowable
                 transitions, making it easier to develop, debug, and
                 understand managed runtimes.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Liu:2012:PAA,
  author =       "P. Liu and C. Zhang",
  title =        "{Pert}: The Application-Aware Tailoring of {Java}
                 Object Persistence",
  journal =      j-IEEE-TRANS-SOFTW-ENG,
  volume =       "38",
  number =       "4",
  pages =        "909--922",
  month =        jul # "\slash " # aug,
  year =         "2012",
  CODEN =        "IESEDJ",
  DOI =          "https://doi.org/10.1109/TSE.2011.66",
  ISSN =         "0098-5589 (print), 1939-3520 (electronic)",
  ISSN-L =       "0098-5589",
  bibdate =      "Thu Feb 1 19:49:24 MST 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ieeetranssoftweng2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=5963692",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE Transactions on Software Engineering",
  journal-URL =  "http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=32",
}

@Book{Long:2012:COS,
  author =       "F. W. (Frederick W.) Long and Dhruv Mohindra and
                 Robert Seacord and Dean Sutherland and David Svoboda",
  title =        "The {CERT} {Oracle} secure coding standard for
                 {Java}",
  publisher =    pub-AW,
  address =      pub-AW,
  pages =        "xxxiv + 699",
  year =         "2012",
  ISBN =         "0-321-80395-7 (paperback)",
  ISBN-13 =      "978-0-321-80395-5 (paperback)",
  LCCN =         "QA76.73.J38 C44 2012",
  bibdate =      "Thu Dec 1 05:58:24 MST 2011",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 z3950.loc.gov:7090/Voyager",
  series =       "The SEI series in software engineering",
  URL =          "http://ptgmedia.pearsoncmg.com/images/9780321803955/samplepages/0321803957.pdf",
  abstract =     "``In the Java world, security is not viewed as an
                 add-on a feature. It is a pervasive way of thinking.
                 Those who forget to think in a secure mindset end up in
                 trouble. But just because the facilities are there
                 doesn't mean that security is assured automatically. A
                 set of standard practices has evolved over the years.
                 The Secure{\'y} Coding{\'y} Standard for Java is a
                 compendium of these practices. These are not
                 theoretical research papers or product marketing
                 blurbs. This is all serious, mission-critical,
                 battle-tested, enterprise-scale stuff.''-- James A.
                 Gosling, Father of the Java Programming Language An
                 essential element of secure coding in the Java
                 programming language is a well-documented and
                 enforceable coding standard. Coding standards encourage
                 programmers to follow a uniform set of rules determined
                 by the requirements of the project and organization,
                 rather than by the programmer's familiarity or
                 preference. Once established, these standards can be
                 used as a metric to evaluate source code (using manual
                 or automated processes). The CERT{\'y} Oracle{\'y}
                 Secure Coding Standard for Java provides rules designed
                 to eliminate insecure coding practices that can lead to
                 exploitable vulnerabilities. Application of the
                 standard's guidelines will lead to higher-quality
                 systems - robust systems that are more resistant to
                 attack. Such guidelines are required for the wide range
                 of products coded in Java - for devices such as PCs,
                 game players, mobile phones, home appliances, and
                 automotive electronics. After a high-level introduction
                 to Java application security, seventeen consistently
                 organized chapters detail specific rules for key areas
                 of Java development. For each area, the authors present
                 noncompliant examples and corresponding compliant
                 solutions, show how to assess risk, and offer
                 references for further information. Each rule is
                 prioritized based on the severity of consequences,
                 likelihood of introducing exploitable vulnerabilities,
                 and cost of remediation. The standard provides secure
                 coding rules for the Java SE 6 Platform including the
                 Java programming language and libraries, and also
                 addresses new features of the Java SE 7 Platform. It
                 describes language behaviors left to the discretion of
                 JVM and compiler implementers, guides developers in the
                 proper use of Java's APIs and security architecture,
                 and considers security concerns pertaining to standard
                 extension APIs (from the javax package hierarchy).",
  acknowledgement = ack-nhfb,
  subject =      "Java (Computer program language); Computer security;
                 Oracle (Computer file); Computer programming;
                 Standards",
  tableofcontents = "1: Introduction \\
                 Misplaced Trust \\
                 Injection Attacks \\
                 Leaking Sensitive Data \\
                 Leaking Capabilities \\
                 Denial of Service \\
                 Serialization \\
                 Concurrency, Visibility, and Memory \\
                 Principle of Least Privilege \\
                 Security Managers \\
                 Class Loaders \\
                 Summary \\
                 2: Input Validation and Data Sanitization (IDS) \\
                 Rules \\
                 Risk Assessment Summary \\
                 IDS00-J: Sanitize untrusted data passed across a trust
                 boundary \\
                 IDS01-J: Normalize strings before validating them \\
                 IDS02-J: Canonicalize path names before validating them
                 \\
                 IDS03-J: Do not log unsanitized user input \\
                 IDS04-J: Limit the size of files passed to
                 ZipInputStream \\
                 IDS05-J: Use a subset of ASCII for file and path names
                 \\
                 IDS06-J: Exclude user input from format strings \\
                 IDS07-J: Do not pass untrusted, unsanitized data to the
                 Runtime.exec() method \\
                 IDS08-J: Sanitize untrusted data passed to a regex \\
                 IDS09-J: Do not use locale-dependent methods on
                 locale-dependent data without specifying the
                 appropriate locale \\
                 IDS10-J: Do not split characters between two data
                 structures \\
                 IDS11-J: Eliminate noncharacter code points before
                 validation \\
                 IDS12-J: Perform lossless conversion of String data
                 between differing character encodings \\
                 IDS13-J: Use compatible encodings on both sides of file
                 or network I/O \\
                 3: Declarations and Initialization (DCL) \\
                 Rules \\
                 Risk Assessment Summary \\
                 DCL00-J: Prevent class initialization cycles \\
                 DCL01-J: Do not reuse public identifiers from the Java
                 Standard Library \\
                 DCL02-J: Declare all enhanced for statement loop
                 variables final \\
                 4: Expressions (EXP) \\
                 Rules \\
                 Risk Assessment Summary \\
                 EXP00-J: Do not ignore values returned by methods \\
                 EXP01-J: Never dereference null pointers \\
                 EXP02-J: Use the two-argument Arrays.equals() method to
                 compare the contents of arrays \\
                 EXP03-J: Do not use the equality operators when
                 comparing values of boxed primitives \\
                 EXP04-J: Ensure that autoboxed values have the intended
                 type \\
                 EXP05-J: Do not write more than once to the same
                 variable within an expression \\
                 EXP06-J: Do not use side-effecting expressions in
                 assertions \\
                 5: Numeric Types and Operations (NUM) \\
                 Rules \\
                 Risk Assessment Summary \\
                 NUM00-J: Detect or prevent integer overflow \\
                 NUM01-J: Do not perform bitwise and arithmetic
                 operations on the same data \\
                 NUM02-J: Ensure that division and modulo operations do
                 not result in divide-by-zero errors \\
                 NUM03-J: Use integer types that can fully represent the
                 possible range of unsigned data \\
                 NUM04-J: Do not use floating-point numbers if precise
                 computation is required \\
                 NUM05-J: Do not use denormalized numbers \\
                 NUM06-J: Use the strictfp modifier for floating-point
                 calculation consistency across platforms \\
                 NUM07-J: Do not attempt comparisons with NaN \\
                 NUM08-J: Check floating-point inputs for exceptional
                 values \\
                 NUM09-J: Do not use floating-point variables as loop
                 counters \\
                 NUM10-J: Do not construct BigDecimal objects from
                 floating-point literals \\
                 NUM11-J: Do not compare or inspect the string
                 representation of floating-point values \\
                 NUM12-J: Ensure conversions of numeric types to
                 narrower types do not result in lost or misinterpreted
                 data \\
                 NUM13-J: Avoid loss of precision when converting
                 primitive integers to floating-point \\
                 6: Object Orientation (OBJ) \\
                 Rules \\
                 Risk Assessment Summary \\
                 OBJ00-J: Limit extensibility of classes and methods
                 with invariants to trusted subclasses only \\
                 OBJ01-J: Declare data members as private and provide
                 accessible wrapper methods \\
                 OBJ02-J: Preserve dependencies in subclasses when
                 changing superclasses \\
                 OBJ03-J: Do not mix generic with nongeneric raw types
                 in new code \\
                 OBJ04-J: Provide mutable classes with copy
                 functionality to safely allow passing instances to
                 untrusted code \\
                 OBJ05-J: Defensively copy private mutable class members
                 before returning their references \\
                 OBJ06-J: Defensively copy mutable inputs and mutable
                 internal components \\
                 OBJ07-J: Sensitive classes must not let themselves be
                 copied \\
                 OBJ08-J: Do not expose private members of an outer
                 class from within a nested class \\
                 OBJ09-J: Compare classes and not class names \\
                 OBJ10-J: Do not use public static nonfinal variables
                 \\
                 OBJ11-J: Be wary of letting constructors throw
                 exceptions \\
                 7: Methods (MET) \\
                 Rules \\
                 Risk Assessment Summary \\
                 MET00-J: Validate method arguments \\
                 MET01-J: Never use assertions to validate method
                 arguments \\
                 MET02-J: Do not use deprecated or obsolete classes or
                 methods \\
                 MET03-J: Methods that perform a security check must be
                 declared private or final \\
                 MET04-J: Do not increase the accessibility of
                 overridden or hidden methods \\
                 MET05-J: Ensure that constructors do not call
                 overridable methods \\
                 MET06-J: Do not invoke overridable methods in clone()
                 \\
                 MET07-J: Never declare a class method that hides a
                 method declared in a superclass or superinterface \\
                 MET08-J: Ensure objects that are equated are equatable
                 \\
                 MET09-J: Classes that define an equals() method must
                 also define a hashCode() method \\
                 MET10-J: Follow the general contract when implementing
                 the compareTo() method \\
                 MET11-J: Ensure that keys used in comparison operations
                 are immutable \\
                 MET12-J: Do not use finalizers \\
                 8: Exceptional Behavior (ERR) \\
                 Rules \\
                 Risk Assessment Summary \\
                 ERR00-J: Do not suppress or ignore checked exceptions
                 \\
                 ERR01-J: Do not allow exceptions to expose sensitive
                 information \\
                 ERR02-J: Prevent exceptions while logging data \\
                 ERR03-J: Restore prior object state on method failure
                 \\
                 ERR04-J: Do not exit abruptly from a finally block \\
                 ERR05-J: Do not let checked exceptions escape from a
                 finally block \\
                 ERR06-J: Do not throw undeclared checked exceptions \\
                 ERR07-J: Do not throw RuntimeException, Exception, or
                 Throwable \\
                 ERR08-J: Do not catch NullPerinterException or any of
                 its ancestors \\
                 ERR09-J: Do not allow untrusted code to terminate the
                 JVM \\
                 9: Visibility and Atomicity (VNA) \\
                 Rules \\
                 Risk Assessment Summary \\
                 VNA00-J: Ensure visibility when accessing shared
                 primitive variables \\
                 VNA01-J: Ensure visibility of shared references to
                 immutable objects \\
                 VNA02-J: Ensure that compound operations on shared
                 variables are atomic \\
                 VNA03-J: Do not assume that a group of calls to
                 independently atomic methods is atomic \\
                 VNA04-J: Ensure that calls to chained methods are
                 atomic \\
                 VNA05-J: Ensure atomicity when reading and writing
                 64-bit values \\
                 10: Locking (LCK) \\
                 Rules \\
                 Risk Assessment Summary \\
                 LCK00-J: Use private final lock objects to synchronize
                 classes that may interact with untrusted code \\
                 LCK01-J: Do not synchronize on objects that may be
                 reused \\
                 LCK02-J: Do not synchronize on the class object
                 returned by getClass() \\
                 LCK03-J: Do not synchronize on the intrinsic locks of
                 high-level concurrency objects \\
                 LCK04-J: Do not synchronize on a collection view if the
                 backing collection is accessible \\
                 LCK05-J: Synchronize access to static fields that can
                 be modified by untrusted code \\
                 LCK06-J: Do not use an instance lock to protect shared
                 static data \\
                 LCK07-J: Avoid deadlock by requesting and releasing
                 locks in the same order \\
                 LCK08-J: Ensure actively held locks are released on
                 exceptional conditions \\
                 LCK09-J: Do not perform operations that can block while
                 holding a lock \\
                 LCK10-J: Do not use incorrect forms of the
                 double-checked locking idiom \\
                 LCK11-J: Avoid client-side locking when using classes
                 that do not commit to their locking strategy \\
                 11: Thread APIs (THI) \\
                 Rules \\
                 Risk Assessment Summary \\
                 THI00-J: Do not invoke Thread.run() \\
                 THI01-J: Do not invoke ThreadGroup methods \\
                 THI02-J: Notify all waiting threads rather than a
                 single thread \\
                 THI03-J: Always invoke wait() and await() methods
                 inside a loop \\
                 THI04-J: Ensure that threads performing blocking
                 operations can be terminated \\
                 THI05-J: Do not use Thread.stop() to terminate threads
                 \\
                 12: Thread Pools (TPS) \\
                 Rules \\
                 Risk Assessment Summary \\
                 TPS00-J: Use thread pools to enable graceful
                 degradation of service during traffic bursts \\
                 TPS01-J: Do not execute interdependent tasks in a
                 bounded thread pool \\
                 TPS02-J: Ensure that tasks submitted to a thread pool
                 are interruptible \\
                 TPS03-J: Ensure that tasks executing in a thread pool
                 do not fail silently \\
                 TPS04-J: Ensure ThreadLocal variables are reinitialized
                 when using thread pools \\
                 13: Thread-Safety Miscellaneous (TSM) \\
                 Rules \\
                 Risk Assessment Summary \\
                 TSM00-J: Do not override thread-safe methods with
                 methods that are not thread-safe \\
                 TSM01-J: Do not let the this reference escape during
                 object construction \\
                 TSM02-J: Do not use background threads during class
                 initialization \\
                 TSM03-J: Do not publish partially initialized objects
                 \\
                 14: Input Output (FIO) \\
                 Rules \\
                 Risk Assessment Summary \\
                 FIO00-J: Do not operate on files in shared directories
                 \\
                 FIO01-J: Create files with appropriate access
                 permissions \\
                 FIO02-J: Detect and handle file-related errors \\
                 FIO03-J: Remove temporary files before termination \\
                 FIO04-J: Close resources when they are no longer needed
                 \\
                 FIO05-J: Do not expose buffers created using the wrap()
                 or duplicate() methods to untrusted code \\
                 FIO06-J: Do not create multiple buffered wrappers on a
                 single InputStream \\
                 FIO07-J: Do not let external processes block on input
                 and output streams \\
                 FIO08-J: Use an int to capture the return value of
                 methods that read a character or byteNote continued:
                 FIO09-J: Do not rely on the write() method to output
                 integers outside the range 0 to 255 \\
                 FIO10-J: Ensure the array is filled when using read()
                 to fill an array \\
                 FIO11-J: Do not attempt to read raw binary data as
                 character data \\
                 FIO12-J: Provide methods to read and write
                 little-endian data \\
                 FI013-J: Do not log sensitive information outside a
                 trust boundary \\
                 FI014-J: Perform proper cleanup at program termination
                 \\
                 15: Serialization (SER) \\
                 Rules \\
                 Risk Assessment Summary \\
                 SER00-J: Maintain serialization compatibility during
                 class evolution \\
                 SER01-J: Do not deviate from the proper signatures of
                 serialization methods \\
                 SER02-J: Sign then seal sensitive objects before
                 sending them across a trust boundary \\
                 SER03-J: Do not serialize unencrypted, sensitive data
                 \\
                 SER04-J: Do not allow serialization and deserialization
                 to bypass the security manager \\
                 SER05-J: Do not serialize instances of inner classes
                 \\
                 SER06-J: Make defensive copies of private mutable
                 components during deserialization \\
                 SER07-J: Do not use the default serialized form for
                 implementation-defined invariants \\
                 SER08-J: Minimize privileges before deserializing from
                 a privileged context \\
                 SER09-J: Do not invoke overridable methods from the
                 readObject() method \\
                 SER10-J: Avoid memory and resource leaks during
                 serialization \\
                 SER11-J: Prevent overwriting of externalizable objects
                 \\
                 16: Platform Security (SEC) \\
                 Rules \\
                 Risk Assessment Summary \\
                 SEC00-J: Do not allow privileged blocks to leak
                 sensitive information across a trust boundary \\
                 SEC01-J: Do not allow tainted variables in privileged
                 blocks \\
                 SEC02-J: Do not base security checks on untrusted
                 sources \\
                 SEC03-J: Do not load trusted classes after allowing
                 untrusted code to load arbitrary classes \\
                 SEC04-J: Protect sensitive operations with security
                 manager checks \\
                 SEC05-J: Do not use reflection to increase
                 accessibility of classes, methods, or fields \\
                 SEC06-J: Do not rely on the default automatic signature
                 verification provided by URLClassLoader and
                 java.util.jar \\
                 SEC07-J: Call the superclass's getPermissions() method
                 when writing a custom class loader \\
                 SEC08-J: Define wrappers around native methods \\
                 17: Runtime Environment (ENV) \\
                 Rules \\
                 Risk Assessment Summary \\
                 ENV00-J: Do not sign code that performs only
                 unprivileged operations \\
                 ENV01-J: Place all security-sensitive code in a single
                 jar and sign and seal it \\
                 ENV02-J: Do not trust the values of environment
                 variables \\
                 ENV03-J: Do not grant dangerous combinations of
                 permissions \\
                 ENV04-J: Do not disable bytecode verification \\
                 ENV05-J: Do not deploy an application that can be
                 remotely monitored \\
                 18: Miscellaneous (MSC) \\
                 Rules \\
                 Risk Assessment Summary \\
                 MSC00-J: Use SSLSocket rather than Socket for secure
                 data exchange \\
                 MSC01-J: Do not use an empty infinite loop \\
                 MSC02-J: Generate strong random numbers \\
                 MSC03-J: Never hard code sensitive information \\
                 MSC04-J: Do not leak memory \\
                 MSC05-J: Do not exhaust heap space \\
                 MSC06-J: Do not modify the underlying collection when
                 an iteration is in progress \\
                 MSC07-J: Prevent multiple instantiations of singleton
                 objects",
}

@Article{Lyon:2012:JTW,
  author =       "Doug Lyon",
  title =        "The {Java} Tree Withers",
  journal =      j-COMPUTER,
  volume =       "45",
  number =       "1",
  pages =        "83--85",
  month =        jan,
  year =         "2012",
  CODEN =        "CPTRB4",
  DOI =          "https://doi.org/10.1109/MC.2012.30",
  ISSN =         "0018-9162 (print), 1558-0814 (electronic)",
  ISSN-L =       "0018-9162",
  bibdate =      "Tue Jan 24 17:27:23 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/computer2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "The Java report card: infrastructure gets a D, code
                 reuse gets an F.",
  acknowledgement = ack-nhfb,
  fjournal =     "Computer",
  journal-URL =  "http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=2",
}

@Article{Magazinius:2012:SWS,
  author =       "Jonas Magazinius and Phu H. Phung and David Sands",
  title =        "Safe Wrappers and Sane Policies for Self Protecting
                 {JavaScript}",
  journal =      j-LECT-NOTES-COMP-SCI,
  volume =       "7127",
  pages =        "239--255",
  year =         "2012",
  CODEN =        "LNCSD9",
  DOI =          "https://doi.org/10.1007/978-3-642-27937-9_17",
  ISSN =         "0302-9743 (print), 1611-3349 (electronic)",
  ISSN-L =       "0302-9743",
  bibdate =      "Wed Dec 19 15:24:40 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/lncs2012b.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-642-27937-9_17/",
  acknowledgement = ack-nhfb,
  book-DOI =     "https://doi.org/10.1007/978-3-642-27937-9",
  book-URL =     "http://www.springerlink.com/content/978-3-642-27937-9",
  fjournal =     "Lecture Notes in Computer Science",
}

@Article{Mayer:2012:ESI,
  author =       "Clemens Mayer and Stefan Hanenberg and Romain Robbes
                 and {\'E}ric Tanter and Andreas Stefik",
  title =        "An empirical study of the influence of static type
                 systems on the usability of undocumented software",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "10",
  pages =        "683--702",
  month =        oct,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2398857.2384666",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Nov 15 16:40:23 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Abstract Although the study of static and dynamic type
                 systems plays a major role in research, relatively
                 little is known about the impact of type systems on
                 software development. Perhaps one of the more common
                 arguments for static type systems in languages such as
                 Java or C++ is that they require developers to annotate
                 their code with type names, which is thus claimed to
                 improve the documentation of software. In contrast, one
                 common argument against static type systems is that
                 they decrease flexibility, which may make them harder
                 to use. While these arguments are found in the
                 literature, rigorous empirical evidence is lacking. We
                 report on a controlled experiment where 27 subjects
                 performed programming tasks on an undocumented API with
                 a static type system (requiring type annotations) as
                 well as a dynamic type system (which does not). Our
                 results show that for some tasks, programmers had
                 faster completion times using a static type system,
                 while for others, the opposite held. We conduct an
                 exploratory study to try and theorize why.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '12 conference proceedings.",
}

@Article{McIntosh:2012:EJB,
  author =       "Shane McIntosh and Bram Adams and Ahmed E. Hassan",
  title =        "The evolution of {Java} build systems",
  journal =      j-EMPIR-SOFTWARE-ENG,
  volume =       "17",
  number =       "4--5",
  pages =        "578--608",
  month =        aug,
  year =         "2012",
  CODEN =        "ESENFW",
  DOI =          "https://doi.org/10.1007/s10664-011-9169-5",
  ISSN =         "1382-3256 (print), 1573-7616 (electronic)",
  ISSN-L =       "1382-3256",
  bibdate =      "Fri Dec 2 09:14:25 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/empir-software-eng.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://link.springer.com/accesspage/article/10.1007/s10664-011-9169-5",
  acknowledgement = ack-nhfb,
  fjournal =     "Empirical Software Engineering",
  journal-URL =  "http://link.springer.com/journal/10664",
}

@Article{McIntyre:2012:FJB,
  author =       "Timothy J. McIntyre and Alexis I. Bishop",
  title =        "{Fringe} --- a {Java}-based finite fringe analysis
                 package",
  journal =      j-COMP-PHYS-COMM,
  volume =       "183",
  number =       "9",
  pages =        "2014--2018",
  month =        sep,
  year =         "2012",
  CODEN =        "CPHCBZ",
  DOI =          "https://doi.org/10.1016/j.cpc.2012.04.011",
  ISSN =         "0010-4655 (print), 1879-2944 (electronic)",
  ISSN-L =       "0010-4655",
  bibdate =      "Thu Jun 7 13:25:14 MDT 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/compphyscomm2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0010465512001506",
  acknowledgement = ack-nhfb,
  fjournal =     "Computer Physics Communications",
  journal-URL =  "http://www.sciencedirect.com/science/journal/00104655",
}

@Article{Meawad:2012:EBS,
  author =       "Fadi Meawad and Gregor Richards and Flor{\'e}al
                 Morandat and Jan Vitek",
  title =        "{Eval} begone!: semi-automated removal of {\tt eval}
                 from {JavaScript} programs",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "10",
  pages =        "607--620",
  month =        oct,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2398857.2384660",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Nov 15 16:40:23 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Eval endows JavaScript developers with great power. It
                 allows developers and end-users, by turning text into
                 executable code, to seamlessly extend and customize the
                 behavior of deployed applications as they are running.
                 With great power comes great responsibility, though not
                 in our experience. In previous work we demonstrated
                 through a large corpus study that programmers wield
                 that power in rather irresponsible and arbitrary ways.
                 We showed that most calls to eval fall into a small
                 number of very predictable patterns. We argued that
                 those patterns could easily be recognized by an
                 automated algorithm and that they could almost always
                 be replaced with safer JavaScript idioms. In this paper
                 we set out to validate our claim by designing and
                 implementing a tool, which we call Evalorizer, that can
                 assist programmers in getting rid of their unneeded
                 evals. We use the tool to remove eval from a real-world
                 website and validated our approach over logs taken from
                 the top 100 websites with a success rate over 97\%
                 under an open world assumption.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '12 conference proceedings.",
}

@Article{Mercer:2012:CVI,
  author =       "Eric Mercer and Suzette Person and Neha Rungta",
  title =        "Computing and visualizing the impact of change with
                 {Java PathFinder} extensions",
  journal =      j-SIGSOFT,
  volume =       "37",
  number =       "6",
  pages =        "1--5",
  month =        nov,
  year =         "2012",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/2382756.2382801",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:16:18 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  abstract =     "Change impact analysis techniques estimate the
                 potential effects of changes made to software. Directed
                 Incremental Symbolic Execution (DiSE) is a Java
                 PathFinder extension that computes the impact of
                 changes on program execution behaviors. The results of
                 DiSE are a set of impacted path conditions that can be
                 efficiently processed by a subsequent client analysis.
                 Path conditions, however, may not be intuitive for
                 software developers without the context of the source
                 code. In this paper we present a framework for
                 visualizing the results of DiSE. The visualization
                 includes annotated source code and control ow graphs
                 indicating program statements that are changed and
                 statements that may be impacted by the changes. A
                 simulation mode enables users to also observe the
                 impact of changes on symbolic execution of the program,
                 by showing the changes to the path conditions as the
                 user steps through the sequences of statements
                 executed.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Mesbah:2012:CAB,
  author =       "Ali Mesbah and Arie van Deursen and Stefan Lenselink",
  title =        "Crawling {Ajax}-Based {Web} Applications through
                 Dynamic Analysis of User Interface State Changes",
  journal =      j-TWEB,
  volume =       "6",
  number =       "1",
  pages =        "3:1--3:??",
  month =        mar,
  year =         "2012",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/2109205.2109208",
  ISSN =         "1559-1131 (print), 1559-114X (electronic)",
  ISSN-L =       "1559-1131",
  bibdate =      "Fri Mar 16 12:37:41 MDT 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/tweb.bib",
  abstract =     "Using JavaScript and dynamic DOM manipulation on the
                 client side of Web applications is becoming a
                 widespread approach for achieving rich interactivity
                 and responsiveness in modern Web applications. At the
                 same time, such techniques---collectively known as
                 Ajax---shatter the concept of webpages with unique
                 URLs, on which traditional Web crawlers are based. This
                 article describes a novel technique for crawling
                 Ajax-based applications through automatic dynamic
                 analysis of user-interface-state changes in Web
                 browsers. Our algorithm scans the DOM tree, spots
                 candidate elements that are capable of changing the
                 state, fires events on those candidate elements, and
                 incrementally infers a state machine that models the
                 various navigational paths and states within an Ajax
                 application. This inferred model can be used in program
                 comprehension and in analysis and testing of dynamic
                 Web states, for instance, or for generating a static
                 version of the application. In this article, we discuss
                 our sequential and concurrent Ajax crawling algorithms.
                 We present our open source tool called Crawljax, which
                 implements the concepts and algorithms discussed in
                 this article. Additionally, we report a number of
                 empirical studies in which we apply our approach to a
                 number of open-source and industrial Web applications
                 and elaborate on the obtained results.",
  acknowledgement = ack-nhfb,
  articleno =    "3",
  fjournal =     "ACM Transactions on the Web (TWEB)",
}

@Article{Mirshokraie:2012:JJA,
  author =       "Shabnam Mirshokraie and Ali Mesbah",
  title =        "{JSART}: {JavaScript} Assertion-Based Regression
                 Testing",
  journal =      j-LECT-NOTES-COMP-SCI,
  volume =       "7387",
  pages =        "238--252",
  year =         "2012",
  CODEN =        "LNCSD9",
  DOI =          "https://doi.org/10.1007/978-3-642-31753-8_18",
  ISSN =         "0302-9743 (print), 1611-3349 (electronic)",
  ISSN-L =       "0302-9743",
  bibdate =      "Wed Dec 19 15:21:29 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/lncs2012f.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-642-31753-8_18/",
  acknowledgement = ack-nhfb,
  book-DOI =     "https://doi.org/10.1007/978-3-642-31753-8",
  book-URL =     "http://www.springerlink.com/content/978-3-642-31753-8",
  fjournal =     "Lecture Notes in Computer Science",
}

@Article{Mirzaei:2012:TAA,
  author =       "Nariman Mirzaei and Sam Malek and Corina S.
                 P{\u{a}}s{\u{a}}reanu and Naeem Esfahani and Riyadh
                 Mahmood",
  title =        "Testing {Android} apps through symbolic execution",
  journal =      j-SIGSOFT,
  volume =       "37",
  number =       "6",
  pages =        "1--5",
  month =        nov,
  year =         "2012",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/2382756.2382798",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:16:18 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  abstract =     "There is a growing need for automated testing
                 techniques aimed at Android apps. A critical challenge
                 is the systematic generation of test cases. One method
                 of systematically generating test cases for Java
                 programs is symbolic execution. But applying symbolic
                 execution tools, such as Symbolic Pathfinder (SPF), to
                 generate test cases for Android apps is challenged by
                 the fact that Android apps run on the Dalvik Virtual
                 Machine (DVM) instead of JVM. In addition, Android apps
                 are event driven and susceptible to path-divergence due
                 to their reliance on an application development
                 framework. This paper provides an overview of a
                 two-pronged approach to alleviate these issues. First,
                 we have developed a model of Android libraries in Java
                 Pathfinder (JPF) to enable execution of Android apps in
                 a way that addresses the issues of incompatibility with
                 JVM and path-divergence. Second, we have leveraged
                 program analysis techniques to correlate events with
                 their handlers for automatically generating
                 Android-specific drivers that simulate all valid
                 events.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Misra:2012:JSC,
  author =       "Janardan Misra and Annervaz KM and Vikrant Kaulgud and
                 Shubhashis Sengupta and Gary Titus",
  title =        "{Java} source-code clustering: Unifying syntactic and
                 semantic features",
  journal =      j-SIGSOFT,
  volume =       "37",
  number =       "6",
  pages =        "1--8",
  month =        nov,
  year =         "2012",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/2382756.2382766",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:16:18 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  abstract =     "This is a report from an international workshop on
                 ``Social and Algorithmic Issues in Business Support''
                 (SAIBS), which was organized in conjunction with the
                 16th ADBIS Conference in Poznan, Poland, on September
                 17, 2012. The main focus of this workshop was to
                 provide a venue for the discussion whether social
                 stands in opposition to algorithmic or systematic. We
                 analyzed social contribution to business processes
                 taking into account possible benefits and risk factors.
                 Questions raised in collected research and discussion
                 related to how far business could relay on social input
                 and what were the limits or what were the areas where
                 introducing crowdsourced components might increase
                 overall risk value to unacceptable level? Algorithmic
                 approach to observe and collect social behaviour was
                 discussed in the context of internet auctions
                 participants and car drivers equipped in mobile
                 application for instant route planning and collecting
                 feedback cartracking data. Having in mind Andrew Keen's
                 critique of social contribution in Web 2.0-related
                 phenomena we looked for the Wisdom of Crowds [1].
                 Collected conclusions and further dissemination of
                 research results should lead to an improvement in
                 utilizing social impact on software development and
                 business processes.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Naik:2012:AT,
  author =       "Mayur Naik and Hongseok Yang and Ghila Castelnuovo and
                 Mooly Sagiv",
  title =        "Abstractions from tests",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "1",
  pages =        "373--386",
  month =        jan,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2103621.2103701",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Mar 15 18:16:55 MDT 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "We present a framework for leveraging dynamic analysis
                 to find good abstractions for static analysis. A static
                 analysis in our framework is parametrised. Our main
                 insight is to directly and efficiently compute from a
                 concrete trace, a necessary condition on the parameter
                 configurations to prove a given query, and thereby
                 prune the space of parameter configurations that the
                 static analysis must consider. We provide constructive
                 algorithms for two instance analyses in our framework:
                 a flow- and context-sensitive thread-escape analysis
                 and a flow- and context-insensitive points-to analysis.
                 We show the efficacy of these analyses, and our
                 approach, on six Java programs comprising two million
                 bytecodes: the thread-escape analysis resolves 80\% of
                 queries on average, disproving 28\% and proving 52\%;
                 the points-to analysis resolves 99\% of queries on
                 average, disproving 29\% and proving 70\%.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "POPL '12 conference proceedings.",
}

@Article{Ngo:2012:BRE,
  author =       "Terry Ngo",
  title =        "Book Review: {{\booktitle{Essential app engine:
                 building high-performance Java apps with Google app
                 engine}} by Adriaan de Jonge}",
  journal =      j-SIGSOFT,
  volume =       "37",
  number =       "2",
  pages =        "37--37",
  month =        mar,
  year =         "2012",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/2108144.2108173",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:16:11 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Nikolic:2012:DEA,
  author =       "{\Dbar}urica Nikoli{\'c} and Fausto Spoto",
  title =        "Definite Expression Aliasing Analysis for {Java}
                 Bytecode",
  journal =      j-LECT-NOTES-COMP-SCI,
  volume =       "7521",
  pages =        "74--89",
  year =         "2012",
  CODEN =        "LNCSD9",
  DOI =          "https://doi.org/10.1007/978-3-642-32943-2_6",
  ISSN =         "0302-9743 (print), 1611-3349 (electronic)",
  ISSN-L =       "0302-9743",
  bibdate =      "Wed Dec 19 15:24:15 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/lncs2012i.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-642-32943-2_6/",
  acknowledgement = ack-nhfb,
  book-DOI =     "https://doi.org/10.1007/978-3-642-32943-2",
  book-URL =     "http://www.springerlink.com/content/978-3-642-32943-2",
  fjournal =     "Lecture Notes in Computer Science",
}

@Article{Nilsen:2012:RTJ,
  author =       "Kelvin Nilsen",
  title =        "Real-time {Java} in modernization of the {Aegis Weapon
                 System}",
  journal =      j-SIGADA-LETTERS,
  volume =       "32",
  number =       "3",
  pages =        "63--70",
  month =        dec,
  year =         "2012",
  CODEN =        "AALEE5",
  DOI =          "https://doi.org/10.1145/2402709.2402699",
  ISSN =         "1094-3641 (print), 1557-9476 (electronic)",
  ISSN-L =       "1094-3641",
  bibdate =      "Sun May 5 10:05:12 MDT 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigada.bib",
  note =         "HILT '12 conference proceedings.",
  abstract =     "The U.S. Navy's Aegis system, considered to be the
                 ``shield of the fleet'', provides area air defense for
                 a carrier battle group in addition to providing
                 long-range ballistic missile defense. A typical Aegis
                 deployment consists of about 100 computers, many of
                 which have multiple cores. The application is
                 distributed, with typical real-time threads spanning 4
                 or 5 different computers. End-to-end distributed thread
                 timing constraints measured from stimulus to response
                 are typically under 100 ms. The target jitter
                 constraints on the individual contributions of
                 processors to the end-to-end deadline constraint are
                 well below 1 ms. The system is fully redundant to
                 support fault tolerance. The software is considered to
                 be safety critical because it aims and fires weapons.
                 The Aegis Weapons System software was recently
                 rewritten into real-time Java as part of the Aegis
                 Modernization activity. This project involved
                 replacement of about 200,000 lines of CMS-2 and Ada
                 code with roughly 500,000 lines of Java. The effort
                 began in 2003 and the new Java implementation of Aegis
                 Weapons System is now being deployed on warships. This
                 paper describes the motivation for the modernization
                 effort and provides a summary of Lockheed Martin's
                 experiences with this project.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGADA Ada Letters",
}

@Article{Nilsen:2012:TOU,
  author =       "Kelvin Nilsen",
  title =        "Tutorial overview: understanding dynamic memory
                 management in safety critical {Java}",
  journal =      j-SIGADA-LETTERS,
  volume =       "32",
  number =       "3",
  pages =        "15--22",
  month =        dec,
  year =         "2012",
  CODEN =        "AALEE5",
  DOI =          "https://doi.org/10.1145/2402709.2402685",
  ISSN =         "1094-3641 (print), 1557-9476 (electronic)",
  ISSN-L =       "1094-3641",
  bibdate =      "Sun May 5 10:05:12 MDT 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigada.bib",
  note =         "HILT '12 conference proceedings.",
  abstract =     "In spite of the high-level abstraction benefits of
                 automatic tracing garbage collection, current
                 prevailing sentiment within the safety certification
                 community is that a simpler memory model is required
                 for the most rigorous levels of software safety
                 certification. Thus, the draft JSR-302 specification
                 for safety critical Java relies on scope-based memory
                 allocation rather than tracing garbage collection. The
                 scoped memory model for JSR-302 is a simplification of
                 the RTSJ model. JSR-302 enforces a strict hierarchy of
                 scopes and distinguishes private scopes, which can be
                 seen only by one thread, from mission scopes, which can
                 be accessed by all the threads that comprise a mission,
                 including threads running within inner-nested
                 sub-missions. The hierarchical memory structure allows
                 implementations to guarantee the absence of memory
                 fragmentation for scope management, unlike the
                 Real-Time Specification for Java from which the JSR-302
                 specification was derived. In the absence of block
                 structure, it is more difficult in Java to safely
                 manage references to stack-allocated objects than in
                 Ada. While the simplified hierarchical management of
                 scoped memory that is part of JSR-302 addresses memory
                 fragmentation concerns, it does not guarantee the
                 absence of dangling pointers. As with the Real-Time
                 Specification for Java, JSR-302 requires a run-time
                 check to enforce that no reference assignment creates a
                 relationship whereby an outer-nested object is allowed
                 to point to an inner-nested object. This rule assures
                 the absence of dangling pointers, but it introduces a
                 different problem: every assignment to a reference
                 field must be accompanied by a run-time check to
                 validate the appropriate scope nesting relationship.
                 This run-time check will throw a run-time exception if
                 the assignment is deemed inappropriate. The safety
                 certification evidence for a given safety-critical Java
                 program must therefore include an argument for every
                 reference assignment that it will not cause the program
                 to abort with a run-time exception. Furthermore, the
                 certification evidence must prove that sufficient
                 memory is available to reliably execute each
                 safety-critical task in the system. This tutorial
                 provides an overview of dynamic memory management in
                 Safety Critical Java and describes two annotation
                 systems that have been designed to support static
                 (compile-time) enforcement of memory safety properties.
                 The first annotation system is described in an appendix
                 to the draft JSR-302 standard. This relatively simple
                 annotation system, which is not considered normative,
                 serves to demonstrate that memory safety can be
                 statically proven without requiring extensive
                 annotations throughout existing library code. The
                 second annotation system is the system implemented in
                 Perc Pico. This annotation system, which is much richer
                 than the draft JSR-302 annotation, has been in
                 experimental use for over five years. During that time,
                 tens of thousands of lines of experimental application
                 code have been developed, with the experience
                 motivating a variety of refinements to the original
                 design.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGADA Ada Letters",
}

@Article{Noll:2012:IDO,
  author =       "Albert Noll and Thomas R. Gross",
  title =        "An infrastructure for dynamic optimization of parallel
                 programs",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "8",
  pages =        "325--326",
  month =        aug,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2370036.2145877",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Wed Sep 12 12:11:57 MDT 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "PPOPP '12 conference proceedings.",
  abstract =     "Object-oriented programming languages like Java
                 provide only low-level constructs (e.g., starting a
                 thread) to describe concurrency. High-level
                 abstractions (e.g., thread pools) are merely provided
                 as a library. As a result, a compiler is not aware of
                 the high-level semantics of a parallel library and
                 therefore misses important optimization opportunities.
                 This paper presents a simple source language extension
                 based on which a compiler is provided with the
                 opportunity to perform new optimizations that are
                 particularly effective for parallel code.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Olszak:2012:RJP,
  author =       "Andrzej Olszak and Bo N{\o}rregaard J{\o}rgensen",
  title =        "Remodularizing {Java} programs for improved locality
                 of feature implementations in source code",
  journal =      j-SCI-COMPUT-PROGRAM,
  volume =       "77",
  number =       "3",
  pages =        "131--151",
  day =          "1",
  month =        mar,
  year =         "2012",
  CODEN =        "SCPGD4",
  DOI =          "https://doi.org/10.1016/j.scico.2010.10.007",
  ISSN =         "0167-6423 (print), 1872-7964 (electronic)",
  ISSN-L =       "0167-6423",
  bibdate =      "Sat Feb 4 14:59:10 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/scicomputprogram.bib;
                 http://www.sciencedirect.com/science/journal/01676423",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0167642310001917",
  acknowledgement = ack-nhfb,
  fjournal =     "Science of Computer Programming",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01676423",
}

@Article{Panizo:2012:EJP,
  author =       "Laura Panizo and Mar{\'\i}a del Mar Gallardo",
  title =        "An extension of {Java PathFinder} for hybrid systems",
  journal =      j-SIGSOFT,
  volume =       "37",
  number =       "6",
  pages =        "1--5",
  month =        nov,
  year =         "2012",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/2382756.2382793",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:16:18 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  abstract =     "Hybrid systems are characterized by combining discrete
                 and continuous behaviors. Verification of hybrid
                 systems is, in general, a difficult task due to the
                 potential complexity of the continuous dynamics.
                 Currently, there are different formalisms and tools
                 which are able to analyze specific types of hybrid
                 systems, model checking being one of the most used
                 approaches. In this paper, we describe an extension of
                 Java PathFinder in order to analyze hybrid systems. We
                 apply a general methodology which has been successfully
                 used to extend Spin. This methodology is non-intrusive,
                 and uses external libraries, such as the Parma
                 Polyhedra Library, to abstract the continuous behavior
                 of the hybrid system.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Parizek:2012:PAJ,
  author =       "Pavel Par{\'\i}zek and OndYej Lhot{\'a}k",
  title =        "Predicate abstraction of {Java} programs with
                 collections",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "10",
  pages =        "75--94",
  month =        oct,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2398857.2384623",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Nov 15 16:40:23 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Our goal is to develop precise and scalable
                 verification techniques for Java programs that use
                 collections and properties that depend on their
                 content. We apply the popular approach of predicate
                 abstraction to Java programs and collections. The main
                 challenge in this context is precise and compact
                 modeling of collections that enables practical
                 verification. We define a predicate language for
                 modeling the observable state of Java collections at
                 the interface level. Changes of the state by API
                 methods are captured by weakest preconditions. We adapt
                 existing techniques for construction of abstract
                 programs. Most notably, we designed optimizations based
                 on specific features of the predicate language. We
                 evaluated our approach on Java programs that use
                 collections in advanced ways. Our results show that
                 interesting properties, such as consistency between
                 multiple collections, can be verified using our
                 approach. The properties are specified using logic
                 formulas that involve predicates introduced by our
                 language.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '12 conference proceedings.",
}

@Article{Park:2012:CB,
  author =       "Chang-Seo Park and Koushik Sen",
  title =        "Concurrent breakpoints",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "8",
  pages =        "331--332",
  month =        aug,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2370036.2145880",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Wed Sep 12 12:11:57 MDT 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "PPOPP '12 conference proceedings.",
  abstract =     "In program debugging, reproducibility of bugs is a key
                 requirement. Unfortunately, bugs in concurrent programs
                 are notoriously difficult to reproduce because bugs due
                 to concurrency happen under very specific thread
                 schedules and the likelihood of taking such corner-case
                 schedules during regular testing is very low. We
                 propose concurrent breakpoints, a light-weight and
                 programmatic way to make a concurrency bug
                 reproducible. We describe a mechanism that helps to hit
                 a concurrent breakpoint in a concurrent execution with
                 high probability. We have implemented concurrent
                 breakpoints as a light-weight library for Java and
                 C/C++ programs. We have used the implementation to
                 deterministically reproduce several known
                 non-deterministic bugs in real-world concurrent Java
                 and C/C++ programs with almost 100\% probability.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@InProceedings{Pham-Quang:2012:JAD,
  author =       "Phuong Pham-Quang and Benoit Delinchant",
  title =        "{Java} Automatic Differentiation Tool Using Virtual
                 Operator Overloading",
  crossref =     "Forth:2012:RAA",
  volume =       "87",
  pages =        "241--250",
  year =         "2012",
  DOI =          "https://doi.org/10.1007/978-3-642-30023-3_22",
  bibdate =      "Sat Dec 22 08:35:46 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/lncse.bib",
  URL =          "http://link.springer.com/content/pdf/10.1007/978-3-642-30023-3_22",
  acknowledgement = ack-nhfb,
  book-DOI =     "https://doi.org/10.1007/978-3-642-30023-3",
  book-URL =     "http://www.springerlink.com/content/978-3-642-30023-3",
}

@Article{Phan:2012:SQI,
  author =       "Quoc-Sang Phan and Pasquale Malacaria and Oksana
                 Tkachuk and Corina S. P{\u{a}}s{\u{a}}reanu",
  title =        "Symbolic quantitative information flow",
  journal =      j-SIGSOFT,
  volume =       "37",
  number =       "6",
  pages =        "1--5",
  month =        nov,
  year =         "2012",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/2382756.2382791",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:16:18 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  abstract =     "Quantitative Information Flow (QIF) is a powerful
                 approach to quantify leaks of confidential information
                 in a software system. Here we present a novel method
                 that precisely quantifies information leaks. In order
                 to mitigate the state-space explosion problem, we
                 propose a symbolic representation of data, and a
                 general SMT-based framework to explore systematically
                 the state space. Symbolic Execution fits well with our
                 framework, so we implement a method of QIF analysis
                 employing Symbolic Execution. We develop our method as
                 a prototype tool that can perform QIF analysis for a
                 software system developed in Java. The tool is built on
                 top of Java Pathfinder, an open source model checking
                 platform, and it is the first tool in the field to
                 support information-theoretic QIF analysis.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Pradel:2012:FAP,
  author =       "Michael Pradel and Thomas R. Gross",
  title =        "Fully automatic and precise detection of thread safety
                 violations",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "6",
  pages =        "521--530",
  month =        jun,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2345156.2254126",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Aug 6 16:31:49 MDT 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  note =         "PLDI '12 proceedings.",
  abstract =     "Concurrent, object-oriented programs often use
                 thread-safe library classes. Existing techniques for
                 testing a thread-safe class either rely on tests using
                 the class, on formal specifications, or on both.
                 Unfortunately, these techniques often are not fully
                 automatic as they involve the user in analyzing the
                 output. This paper presents an automatic testing
                 technique that reveals concurrency bugs in supposedly
                 thread-safe classes. The analysis requires as input
                 only the class under test and reports only true
                 positives. The key idea is to generate tests in which
                 multiple threads call methods on a shared instance of
                 the tested class. If a concurrent test exhibits an
                 exception or a deadlock that cannot be triggered in any
                 linearized execution of the test, the analysis reports
                 a thread safety violation. The approach is easily
                 applicable, because it is independent of hand-written
                 tests and explicit specifications. The analysis finds
                 15 concurrency bugs in popular Java libraries,
                 including two previously unknown bugs in the Java
                 standard library.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Ramirez-Deantes:2012:MTA,
  author =       "D. Ram{\'\i}rez-Deantes and J. Correas and G. Puebla",
  title =        "Modular Termination Analysis of {Java} Bytecode and
                 Its Application to {phoneME} Core Libraries",
  journal =      j-LECT-NOTES-COMP-SCI,
  volume =       "6921",
  pages =        "218--236",
  year =         "2012",
  CODEN =        "LNCSD9",
  DOI =          "https://doi.org/10.1007/978-3-642-27269-1_13",
  ISSN =         "0302-9743 (print), 1611-3349 (electronic)",
  ISSN-L =       "0302-9743",
  bibdate =      "Wed Dec 19 15:20:22 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/lncs2012a.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-642-27269-1_13/",
  acknowledgement = ack-nhfb,
  book-DOI =     "https://doi.org/10.1007/978-3-642-27269-1",
  book-URL =     "http://www.springerlink.com/content/978-3-642-27269-1",
  fjournal =     "Lecture Notes in Computer Science",
}

@Article{Ravn:2012:SCJ,
  author =       "Anders P. Ravn and Martin Schoeberl",
  title =        "Safety-critical {Java} with cyclic executives on
                 chip-multiprocessors",
  journal =      j-CCPE,
  volume =       "24",
  number =       "8",
  pages =        "772--788",
  month =        "????",
  year =         "2012",
  CODEN =        "CCPEBO",
  DOI =          "https://doi.org/10.1002/cpe.1754",
  ISSN =         "1532-0626 (print), 1532-0634 (electronic)",
  ISSN-L =       "1532-0626",
  bibdate =      "Sat May 26 08:11:47 MDT 2012",
  bibsource =    "http://www.interscience.wiley.com/jpages/1532-0626;
                 https://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Concurrency and Computation: Prac\-tice and
                 Experience",
  journal-URL =  "http://www.interscience.wiley.com/jpages/1532-0626",
  onlinedate =   "10 May 2011",
}

@Article{Razafindralambo:2012:FFH,
  author =       "Tiana Razafindralambo and Guillaume Bouffard and
                 Jean-Louis Lanet",
  title =        "A Friendly Framework for Hidding fault enabled virus
                 for {Java} Based {Smartcard}",
  journal =      j-LECT-NOTES-COMP-SCI,
  volume =       "7371",
  pages =        "122--128",
  year =         "2012",
  CODEN =        "LNCSD9",
  DOI =          "https://doi.org/10.1007/978-3-642-31540-4_10",
  ISSN =         "0302-9743 (print), 1611-3349 (electronic)",
  ISSN-L =       "0302-9743",
  bibdate =      "Wed Dec 19 15:21:06 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/lncs2012f.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-642-31540-4_10/",
  acknowledgement = ack-nhfb,
  book-DOI =     "https://doi.org/10.1007/978-3-642-31540-4",
  book-URL =     "http://www.springerlink.com/content/978-3-642-31540-4",
  fjournal =     "Lecture Notes in Computer Science",
}

@Article{Reichenbach:2012:PPD,
  author =       "Christoph Reichenbach and Yannis Smaragdakis and Neil
                 Immerman",
  title =        "{PQL}: a Purely-Declarative {Java} Extension for
                 Parallel Programming",
  journal =      j-LECT-NOTES-COMP-SCI,
  volume =       "7313",
  pages =        "53--78",
  year =         "2012",
  CODEN =        "LNCSD9",
  DOI =          "https://doi.org/10.1007/978-3-642-31057-7_4",
  ISSN =         "0302-9743 (print), 1611-3349 (electronic)",
  ISSN-L =       "0302-9743",
  bibdate =      "Wed Dec 19 15:19:51 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/lncs2012e.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-642-31057-7_4/",
  acknowledgement = ack-nhfb,
  book-DOI =     "https://doi.org/10.1007/978-3-642-31057-7",
  book-URL =     "http://www.springerlink.com/content/978-3-642-31057-7",
  fjournal =     "Lecture Notes in Computer Science",
}

@Article{Reza:2012:JS,
  author =       "Juan Rolando Reza",
  title =        "{Java} supervenience",
  journal =      j-COMP-LANGS-SYS-STRUCT,
  volume =       "38",
  number =       "1",
  pages =        "73--97",
  month =        apr,
  year =         "2012",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1016/j.cl.2011.08.002",
  ISSN =         "1477-8424 (print), 1873-6866 (electronic)",
  ISSN-L =       "1477-8424",
  bibdate =      "Wed Apr 11 16:28:12 MDT 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/complngs.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://www.sciencedirect.com/science/journal/14778424",
  URL =          "http://www.sciencedirect.com/science/article/pii/S1477842411000182",
  acknowledgement = ack-nhfb,
  fjournal =     "Computer Languages, Systems {\&} Structures",
  journal-URL =  "http://www.sciencedirect.com/science/journal/14778424",
}

@Article{Rimlinger:2012:TGS,
  author =       "Frank Rimlinger",
  title =        "Test generation via symbolic simulation",
  journal =      j-SIGSOFT,
  volume =       "37",
  number =       "6",
  pages =        "1--5",
  month =        nov,
  year =         "2012",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/2382756.2382795",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:16:18 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  abstract =     "The Mango extension project of JPF is an Eclipse
                 Workbench plugin which creates a functional
                 specification of Java source code. The specification is
                 presented as a series of navigable pages within Eclipse
                 views. Representative code examples containing faults
                 are processed by Mango. The output specification views
                 are then navigated for the purpose of discovering
                 robust fault recognition rules for automated testing.
                 This paper describes how the analyst and tool work
                 together to generate a test for a selected
                 vulnerability described in an Oracle publication, the
                 exposition of confidential data by the exception
                 handler mechanism.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Rompf:2012:LMS,
  author =       "Tiark Rompf and Martin Odersky",
  title =        "Lightweight modular staging: a pragmatic approach to
                 runtime code generation and compiled {DSLs}",
  journal =      j-CACM,
  volume =       "55",
  number =       "6",
  pages =        "121--130",
  month =        jun,
  year =         "2012",
  CODEN =        "CACMA2",
  DOI =          "https://doi.org/10.1145/2184319.2184345",
  ISSN =         "0001-0782 (print), 1557-7317 (electronic)",
  ISSN-L =       "0001-0782",
  bibdate =      "Wed Jun 6 15:21:16 MDT 2012",
  bibsource =    "http://www.acm.org/pubs/contents/journals/cacm/;
                 https://www.math.utah.edu/pub/tex/bib/cacm2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "Good software engineering practice demands
                 generalization and abstraction, whereas high
                 performance demands specialization and concretization.
                 These goals are at odds, and compilers can only rarely
                 translate expressive high-level programs to modern
                 hardware platforms in a way that makes best use of the
                 available resources. Generative programming is a
                 promising alternative to fully automatic translation.
                 Instead of writing down the target program directly,
                 developers write a program generator, which produces
                 the target program as its output. The generator can be
                 written in a high-level, generic style and can still
                 produce efficient, specialized target programs. In
                 practice, however, developing high-quality program
                 generators requires a very large effort that is often
                 hard to amortize. We present lightweight modular
                 staging (LMS), a generative programming approach that
                 lowers this effort significantly. LMS seamlessly
                 combines program generator logic with the generated
                 code in a single program, using only types to
                 distinguish the two stages of execution. Through
                 extensive use of component technology, LMS makes a
                 reusable and extensible compiler framework available at
                 the library level, allowing programmers to tightly
                 integrate domain-specific abstractions and
                 optimizations into the generation process, with common
                 generic optimizations provided by the framework. LMS is
                 well suited to develop embedded domain-specific
                 languages (DSLs) and has been used to develop powerful
                 performance-oriented DSLs for demanding domains such as
                 machine learning, with code generation for
                 heterogeneous platforms including GPUs. LMS has also
                 been used to generate SQL for embedded database queries
                 and JavaScript for web applications.",
  acknowledgement = ack-nhfb,
  fjournal =     "Communications of the ACM",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J79",
}

@Article{Samuelson:2012:LSO,
  author =       "Pamela Samuelson",
  title =        "Legally speaking: {Oracle} v. {Google}: are {APIs}
                 copyrightable?",
  journal =      j-CACM,
  volume =       "55",
  number =       "11",
  pages =        "25--27",
  month =        nov,
  year =         "2012",
  CODEN =        "CACMA2",
  DOI =          "https://doi.org/10.1145/2366316.2366325",
  ISSN =         "0001-0782 (print), 1557-7317 (electronic)",
  ISSN-L =       "0001-0782",
  bibdate =      "Thu Oct 25 09:59:18 MDT 2012",
  bibsource =    "http://www.acm.org/pubs/contents/journals/cacm/;
                 https://www.math.utah.edu/pub/tex/bib/cacm2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "Assessing the first phase of the trial based on claims
                 that Google's Android platform infringes Oracle's
                 Java-related copyrights and patents.",
  acknowledgement = ack-nhfb,
  fjournal =     "Communications of the ACM",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J79",
}

@Article{Sartor:2012:EMT,
  author =       "Jennfer B. Sartor and Lieven Eeckhout",
  title =        "Exploring multi-threaded {Java} application
                 performance on multicore hardware",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "10",
  pages =        "281--296",
  month =        oct,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2398857.2384638",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Nov 15 16:40:23 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  abstract =     "While there have been many studies of how to schedule
                 applications to take advantage of increasing numbers of
                 cores in modern-day multicore processors, few have
                 focused on multi-threaded managed language applications
                 which are prevalent from the embedded to the server
                 domain. Managed languages complicate performance
                 studies because they have additional virtual machine
                 threads that collect garbage and dynamically compile,
                 closely interacting with application threads. Further
                 complexity is introduced as modern multicore machines
                 have multiple sockets and dynamic frequency scaling
                 options, broadening opportunities to reduce both power
                 and running time. In this paper, we explore the
                 performance of Java applications, studying how best to
                 map application and virtual machine (JVM) threads to a
                 multicore, multi-socket environment. We explore both
                 the cost of separating JVM threads from application
                 threads, and the opportunity to speed up or slow down
                 the clock frequency of isolated threads. We perform
                 experiments with the multi-threaded DaCapo benchmarks
                 and pseudojbb2005 running on the Jikes Research Virtual
                 Machine, on a dual-socket, 8-core Intel Nehalem machine
                 to reveal several novel, and sometimes
                 counter-intuitive, findings. We believe these insights
                 are a first but important step towards understanding
                 and optimizing managed language performance on modern
                 hardware.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '12 conference proceedings.",
}

@Article{Schafer:2012:CAN,
  author =       "M. Sch{\"a}fer and A. Thies and F. Steimann and F.
                 Tip",
  title =        "A Comprehensive Approach to Naming and Accessibility
                 in Refactoring {Java} Programs",
  journal =      j-IEEE-TRANS-SOFTW-ENG,
  volume =       "38",
  number =       "6",
  pages =        "1233--1257",
  month =        nov # "\slash " # dec,
  year =         "2012",
  CODEN =        "IESEDJ",
  DOI =          "https://doi.org/10.1109/TSE.2012.13",
  ISSN =         "0098-5589 (print), 1939-3520 (electronic)",
  ISSN-L =       "0098-5589",
  bibdate =      "Thu Feb 1 19:49:24 MST 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ieeetranssoftweng2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=6152131",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE Transactions on Software Engineering",
  journal-URL =  "http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=32",
}

@Article{Scheben:2012:VIF,
  author =       "Christoph Scheben and Peter H. Schmitt",
  title =        "Verification of Information Flow Properties of {Java}
                 Programs without Approximations",
  journal =      j-LECT-NOTES-COMP-SCI,
  volume =       "7421",
  pages =        "232--249",
  year =         "2012",
  CODEN =        "LNCSD9",
  DOI =          "https://doi.org/10.1007/978-3-642-31762-0_15",
  ISSN =         "0302-9743 (print), 1611-3349 (electronic)",
  ISSN-L =       "0302-9743",
  bibdate =      "Wed Dec 19 15:22:12 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/lncs2012g.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-642-31762-0_15/",
  acknowledgement = ack-nhfb,
  book-DOI =     "https://doi.org/10.1007/978-3-642-31762-0",
  book-URL =     "http://www.springerlink.com/content/978-3-642-31762-0",
  fjournal =     "Lecture Notes in Computer Science",
}

@Article{Severance:2012:DJO,
  author =       "Charles Severance",
  title =        "Discovering {JavaScript} Object Notation",
  journal =      j-COMPUTER,
  volume =       "45",
  number =       "4",
  pages =        "6--8",
  month =        apr,
  year =         "2012",
  CODEN =        "CPTRB4",
  DOI =          "https://doi.org/10.1109/MC.2012.132",
  ISSN =         "0018-9162 (print), 1558-0814 (electronic)",
  ISSN-L =       "0018-9162",
  bibdate =      "Thu Apr 26 16:52:47 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/computer2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Computer",
  journal-URL =  "http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=2",
}

@Article{Severance:2012:JDL,
  author =       "Charles Severance",
  title =        "{JavaScript}: Designing a Language in 10 Days",
  journal =      j-COMPUTER,
  volume =       "45",
  number =       "2",
  pages =        "7--8",
  month =        feb,
  year =         "2012",
  CODEN =        "CPTRB4",
  DOI =          "https://doi.org/10.1109/MC.2012.57",
  ISSN =         "0018-9162 (print), 1558-0814 (electronic)",
  ISSN-L =       "0018-9162",
  bibdate =      "Thu Mar 15 16:00:49 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/computer2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Computer",
  journal-URL =  "http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=2",
}

@Article{Sewe:2012:NSI,
  author =       "Andreas Sewe and Mira Mezini and Aibek Sarimbekov and
                 Danilo Ansaloni and Walter Binder and Nathan Ricci and
                 Samuel Z. Guyer",
  title =        "{{\tt New Scala() instanceof}} {Java}: a comparison of
                 the memory behaviour of {Java} and {Scala} programs",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "11",
  pages =        "97--108",
  month =        nov,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2426642.2259010",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Jan 10 08:55:30 MST 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  note =         "ISMM '12 conference proceedings.",
  abstract =     "While often designed with a single language in mind,
                 managed runtimes like the Java virtual machine (JVM)
                 have become the target of not one but many languages,
                 all of which benefit from the runtime's services. One
                 of these services is automatic memory management. In
                 this paper, we compare and contrast the memory
                 behaviour of programs written in Java and Scala,
                 respectively, two languages which both target the same
                 platform: the JVM. We both analyze core object
                 demographics like object lifetimes as well as secondary
                 properties of objects like their associated monitors
                 and identity hash-codes. We find that objects in Scala
                 programs have lower survival rates and higher rates of
                 immutability, which is only partly explained by the
                 memory behaviour of objects representing closures or
                 boxed primitives. Other metrics vary more by benchmark
                 than language.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Sewell:2012:TJ,
  author =       "Peter Sewell",
  title =        "Tales from the jungle",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "9",
  pages =        "271--272",
  month =        sep,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2398856.2364566",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Nov 15 16:40:19 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "We rely on a computational infrastructure that is a
                 densely interwined mass of software and hardware:
                 programming languages, network protocols, operating
                 systems, and processors. It has accumulated great
                 complexity, from a combination of engineering design
                 decisions, contingent historical choices, and sheer
                 scale, yet it is defined at best by prose
                 specifications, or, all too often, just by the common
                 implementations. Can we do better? More specifically,
                 can we apply rigorous methods to this mainstream
                 infrastructure, taking the accumulated complexity
                 seriously, and if we do, does it help? My colleagues
                 and I have looked at these questions in several
                 contexts: the TCP/IP network protocols with their
                 Sockets API; programming language design, including the
                 Java module system and the C11/C++11 concurrency model;
                 the hardware concurrency behaviour of x86, IBM POWER,
                 and ARM multiprocessors; and compilation of concurrent
                 code. In this talk I will draw some lessons from what
                 did and did not succeed, looking especially at the
                 empirical nature of some of the work, at the social
                 process of engagement with the various different
                 communities, and at the mathematical and software tools
                 we used. Domain-specific modelling languages (based on
                 functional programming ideas) and proof assistants were
                 invaluable for working with the large and loose
                 specifications involved: idioms within HOL4 for TCP,
                 our Ott tool for programming language specification,
                 and Owens's Lem tool for portable semantic definitions,
                 with HOL4, Isabelle, and Coq, for the relaxed-memory
                 concurrency semantics work. Our experience with these
                 suggests something of what is needed to make full-scale
                 rigorous semantics a commonplace reality.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "ICFP '12 conference proceedings.",
}

@Article{Shafiei:2012:MCL,
  author =       "Nastaran Shafiei and Peter Mehlitz",
  title =        "Modeling class loaders in {Java PathFinder} version
                 7",
  journal =      j-SIGSOFT,
  volume =       "37",
  number =       "6",
  pages =        "1--5",
  month =        nov,
  year =         "2012",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/2382756.2382800",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:16:18 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  abstract =     "The class loading mechanism is one of the essential
                 components of the Java runtime environment. Java class
                 loading is performed on-demand, allows multiple, user
                 extensible class loaders, and can associate a separate
                 type namespace with each class loader. Previous
                 versions of the Java Pathfinder (JPF) model checker
                 only provided a single, hardcoded class loading
                 mechanism. As one of the cornerstones of the upcoming
                 JPF version 7 (JPF v7), we have implemented a standard
                 Java conforming class loader infrastructure. Our
                 implementation does not only support different class
                 loaders and type namespaces, but also allows explicit
                 instantiation of multiple bootstrap class loaders which
                 is essential for model checking of distributed
                 applications --- the primary motivation for our work.
                 With the new class loading mechanism, such applications
                 can be mapped to threads using different bootstrap
                 class loaders, thus effectively separating all static
                 fields between application threads. In addition, the
                 JPF v7 class loading is considered to be the basis for
                 future verification of Java security properties.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Shah:2012:AMJ,
  author =       "Syed Muhammad Ali Shah and Jens Dietrich and Catherine
                 McCartin",
  title =        "On the Automated Modularisation of {Java} Programs
                 Using Service Locators",
  journal =      j-LECT-NOTES-COMP-SCI,
  volume =       "7306",
  pages =        "132--147",
  year =         "2012",
  CODEN =        "LNCSD9",
  DOI =          "https://doi.org/10.1007/978-3-642-30564-1_9",
  ISSN =         "0302-9743 (print), 1611-3349 (electronic)",
  ISSN-L =       "0302-9743",
  bibdate =      "Wed Dec 19 15:19:42 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/lncs2012e.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-642-30564-1_9/",
  acknowledgement = ack-nhfb,
  book-DOI =     "https://doi.org/10.1007/978-3-642-30564-1",
  book-URL =     "http://www.springerlink.com/content/978-3-642-30564-1",
  fjournal =     "Lecture Notes in Computer Science",
}

@Article{Shan:2012:OAC,
  author =       "Zhe Shan and Akhil Kumar",
  title =        "Optimal Adapter Creation for Process Composition in
                 Synchronous vs. Asynchronous Communication",
  journal =      j-TMIS,
  volume =       "3",
  number =       "2",
  pages =        "8:1--8:??",
  month =        jul,
  year =         "2012",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/2229156.2229160",
  ISSN =         "2158-656X (print), 2158-6578 (electronic)",
  ISSN-L =       "2158-656X",
  bibdate =      "Tue Nov 6 19:02:09 MST 2012",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tmis/;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/tmis.bib",
  abstract =     "A key issue in process-aware e-commerce collaboration
                 is to orchestrate business processes of multiple
                 business partners throughout a supply chain network in
                 an automated and seamless way. Since each partner has
                 its own internal processes with different control flow
                 structures and message interfaces, the real challenge
                 lies in verifying the correctness of process
                 collaboration, and reconciling conflicts in an
                 automated manner to make collaboration successful. The
                 purpose of business process adaptation is to mediate
                 the communication between independent processes to
                 overcome their mismatches and incompatibilities. The
                 goal of this article is to develop and compare
                 efficient approaches of optimal adapter (i.e. one that
                 minimizes the number of messages to be adapted)
                 creation for multiple interacting processes under both
                 synchronous and asynchronous communication. We start
                 with an analysis of interactions of each message pair,
                 and show how to identify incompatible cases and their
                 adaptation elements for both types of communication.
                 Then, we show how to extend this analysis into more
                 general cases involving M messages and N processes ( M,
                 N {$>$} 2). Further, we present optimal adapter
                 creation algorithms for both scenarios based on our
                 analysis technique. The algorithms were implemented in
                 a Java-based prototype system, and results of two
                 experiments are reported. We compare and discuss the
                 insights gained about adapter creation in these two
                 scenarios.",
  acknowledgement = ack-nhfb,
  articleno =    "8",
  fjournal =     "ACM Transactions on Management Information Systems
                 (TMIS)",
}

@Article{Siek:2012:FDT,
  author =       "Konrad Siek and Pawe{\l} T. Wojciechowski",
  title =        "A Formal Design of a Tool for Static Analysis of Upper
                 Bounds on Object Calls in {Java}",
  journal =      j-LECT-NOTES-COMP-SCI,
  volume =       "7437",
  pages =        "192--206",
  year =         "2012",
  CODEN =        "LNCSD9",
  DOI =          "https://doi.org/10.1007/978-3-642-32469-7_13",
  ISSN =         "0302-9743 (print), 1611-3349 (electronic)",
  ISSN-L =       "0302-9743",
  bibdate =      "Wed Dec 19 15:22:33 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/lncs2012g.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-642-32469-7_13/",
  acknowledgement = ack-nhfb,
  book-DOI =     "https://doi.org/10.1007/978-3-642-32469-7",
  book-URL =     "http://www.springerlink.com/content/978-3-642-32469-7",
  fjournal =     "Lecture Notes in Computer Science",
}

@Article{Simao:2012:CER,
  author =       "Jos{\'e} Sim{\~a}o and Tiago Garrochinho and Lu{\'\i}s
                 Veiga",
  title =        "A checkpointing-enabled and resource-aware {Java
                 Virtual Machine} for efficient and robust {e-Science}
                 applications in grid environments",
  journal =      j-CCPE,
  volume =       "24",
  number =       "13",
  pages =        "1421--1442",
  day =          "10",
  month =        sep,
  year =         "2012",
  CODEN =        "CCPEBO",
  DOI =          "https://doi.org/10.1002/cpe.1879",
  ISSN =         "1532-0626 (print), 1532-0634 (electronic)",
  ISSN-L =       "1532-0626",
  bibdate =      "Mon Nov 5 07:44:52 MST 2012",
  bibsource =    "http://www.interscience.wiley.com/jpages/1532-0626;
                 https://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Concurrency and Computation: Practice and Experience",
  journal-URL =  "http://www.interscience.wiley.com/jpages/1532-0626",
  onlinedate =   "21 Dec 2011",
}

@Article{Singh:2012:EPS,
  author =       "Abhayendra Singh and Daniel Marino and Satish
                 Narayanasamy and Todd Millstein and Madan Musuvathi",
  title =        "Efficient processor support for {DRFx}, a memory model
                 with exceptions",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "4",
  pages =        "53--66",
  month =        apr,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2248487.1950375",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Jun 7 08:15:03 MDT 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "A longstanding challenge of shared-memory concurrency
                 is to provide a memory model that allows for efficient
                 implementation while providing strong and simple
                 guarantees to programmers. The C++0x and Java memory
                 models admit a wide variety of compiler and hardware
                 optimizations and provide sequentially consistent (SC)
                 semantics for data-race-free programs. However, they
                 either do not provide any semantics (C++0x) or provide
                 a hard-to-understand semantics (Java) for racy
                 programs, compromising the safety and debuggability of
                 such programs. In earlier work we proposed the DRFx
                 memory model, which addresses this problem by
                 dynamically detecting potential violations of SC due to
                 the interaction of compiler or hardware optimizations
                 with data races and halting execution upon detection.
                 In this paper, we present a detailed micro-architecture
                 design for supporting the DRFx memory model, formalize
                 the design and prove its correctness, and evaluate the
                 design using a hardware simulator. We describe a set of
                 DRFx-compliant complexity-effective optimizations which
                 allow us to attain performance close to that of TSO
                 (Total Store Model) and DRF0 while providing strong
                 guarantees for all programs.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "ASPLOS '12 conference proceedings.",
}

@Article{Snellenburg:2012:GJB,
  author =       "Joris J. Snellenburg and Sergey Laptenok and Ralf
                 Seger and Katharine M. Mullen and Ivo H. M. van
                 Stokkum",
  title =        "{Glotaran}: a {Java}-Based Graphical User Interface
                 for the {R} Package {TIMP}",
  journal =      j-J-STAT-SOFT,
  volume =       "49",
  number =       "3",
  pages =        "??--??",
  month =        jun,
  year =         "2012",
  CODEN =        "JSSOBK",
  ISSN =         "1548-7660",
  bibdate =      "Mon Oct 29 18:54:10 MDT 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/jstatsoft.bib",
  URL =          "http://www.jstatsoft.org/v49/i03",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Statistical Software",
  journal-URL =  "http://www.jstatsoft.org/",
  pubdates =     "Submitted 2011-01-20; Accepted 2011-09-16",
}

@Article{Sridharan:2012:CTP,
  author =       "Manu Sridharan and Julian Dolby and Satish Chandra and
                 Max Sch{\"a}fer and Frank Tip",
  title =        "Correlation Tracking for Points-To Analysis of
                 {JavaScript}",
  journal =      j-LECT-NOTES-COMP-SCI,
  volume =       "7313",
  pages =        "435--458",
  year =         "2012",
  CODEN =        "LNCSD9",
  DOI =          "https://doi.org/10.1007/978-3-642-31057-7_20",
  ISSN =         "0302-9743 (print), 1611-3349 (electronic)",
  ISSN-L =       "0302-9743",
  bibdate =      "Wed Dec 19 15:19:51 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/lncs2012e.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-642-31057-7_20/",
  acknowledgement = ack-nhfb,
  book-DOI =     "https://doi.org/10.1007/978-3-642-31057-7",
  book-URL =     "http://www.springerlink.com/content/978-3-642-31057-7",
  fjournal =     "Lecture Notes in Computer Science",
}

@Article{Stuchlik:2012:SVD,
  author =       "Andreas Stuchlik and Stefan Hanenberg",
  title =        "Static vs. dynamic type systems: an empirical study
                 about the relationship between type casts and
                 development time",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "2",
  pages =        "97--106",
  month =        feb,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2168696.2047861",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Apr 20 17:34:09 MDT 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Static type systems are essential in computer science.
                 However, there is hardly any knowledge about the impact
                 of type systems on the resulting piece of software.
                 While there are authors that state that static types
                 increase the development speed, other authors argue the
                 other way around. A previous experiment suggests that
                 there are multiple factors that play a role for a
                 comparison of statically and dynamically typed
                 language. As a follow-up, this paper presents an
                 empirical study with 21 subjects that compares
                 programming tasks performed in Java and Groovy ---
                 programming tasks where the number of expected type
                 casts vary in the statically typed language. The result
                 of the study is, that the dynamically typed group
                 solved the complete programming tasks significantly
                 faster for most tasks --- but that for larger tasks
                 with a higher number of type casts no significant
                 difference could be found.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "DSL '11 conference proceedings.",
}

@Article{Szweda:2012:ANB,
  author =       "{\L}ukasz Szweda and Daniel Wilusz and Jakub
                 Floty{\'n}ski",
  title =        "Application of {NXT} Based Robots for Teaching
                 {Java}-Based Concurrency",
  journal =      j-LECT-NOTES-COMP-SCI,
  volume =       "7516",
  pages =        "54--64",
  year =         "2012",
  CODEN =        "LNCSD9",
  DOI =          "https://doi.org/10.1007/978-3-642-33466-5_6",
  ISSN =         "0302-9743 (print), 1611-3349 (electronic)",
  ISSN-L =       "0302-9743",
  bibdate =      "Wed Dec 19 15:24:08 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/lncs2012i.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-642-33466-5_6/",
  acknowledgement = ack-nhfb,
  book-DOI =     "https://doi.org/10.1007/978-3-642-33466-5",
  book-URL =     "http://www.springerlink.com/content/978-3-642-33466-5",
  fjournal =     "Lecture Notes in Computer Science",
}

@Article{Taboada:2012:FMS,
  author =       "Guillermo L. Taboada and Juan Touri{\~n}o and
                 Ram{\'o}n Doallo",
  title =        "{F-MPJ}: scalable {Java} message-passing
                 communications on parallel systems",
  journal =      j-J-SUPERCOMPUTING,
  volume =       "60",
  number =       "1",
  pages =        "117--140",
  month =        apr,
  year =         "2012",
  CODEN =        "JOSUED",
  ISSN =         "0920-8542 (print), 1573-0484 (electronic)",
  ISSN-L =       "0920-8542",
  bibdate =      "Fri Apr 6 17:45:24 MDT 2012",
  bibsource =    "http://springerlink.metapress.com/openurl.asp?genre=issue&issn=0920-8542&volume=60&issue=1;
                 https://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/jsuper.bib",
  URL =          "http://www.springerlink.com/openurl.asp?genre=article&issn=0920-8542&volume=60&issue=1&spage=117",
  acknowledgement = ack-nhfb,
  fjournal =     "The Journal of Supercomputing",
  journal-URL =  "http://link.springer.com/journal/11227",
}

@Article{Takikawa:2012:GTF,
  author =       "Asumu Takikawa and T. Stephen Strickland and Christos
                 Dimoulas and Sam Tobin-Hochstadt and Matthias
                 Felleisen",
  title =        "Gradual typing for first-class classes",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "10",
  pages =        "793--810",
  month =        oct,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2398857.2384674",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Nov 15 16:40:23 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/python.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Dynamic type-checking and object-oriented programming
                 often go hand-in-hand; scripting languages such as
                 Python, Ruby, and JavaScript all embrace
                 object-oriented (OO) programming. When scripts written
                 in such languages grow and evolve into large programs,
                 the lack of a static type discipline reduces
                 maintainability. A programmer may thus wish to migrate
                 parts of such scripts to a sister language with a
                 static type system. Unfortunately, existing type
                 systems neither support the flexible OO composition
                 mechanisms found in scripting languages nor accommodate
                 sound interoperation with untyped code. In this paper,
                 we present the design of a gradual typing system that
                 supports sound interaction between statically- and
                 dynamically-typed units of class-based code. The type
                 system uses row polymorphism for classes and thus
                 supports mixin-based OO composition. To protect
                 migration of mixins from typed to untyped components,
                 the system employs a novel form of contracts that
                 partially seal classes. The design comes with a theorem
                 that guarantees the soundness of the type system even
                 in the presence of untyped components.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '12 conference proceedings.",
}

@Article{Tamayo:2012:UBD,
  author =       "Juan M. Tamayo and Alex Aiken and Nathan Bronson and
                 Mooly Sagiv",
  title =        "Understanding the behavior of database operations
                 under program control",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "10",
  pages =        "983--996",
  month =        oct,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2398857.2384688",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Nov 15 16:40:23 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Applications that combine general program logic with
                 persistent databases (e.g., three-tier applications)
                 often suffer large performance penalties from poor use
                 of the database. We introduce a program analysis
                 technique that combines information flow in the program
                 with commutativity analysis of its database operations
                 to produce a unified dependency graph for database
                 statements, which provides programmers with a
                 high-level view of how costly database operations are
                 and how they are connected in the program. As an
                 example application of our analysis we describe three
                 optimizations that can be discovered by examining the
                 structure of the dependency graph; each helps remove
                 communication latency from the critical path of a
                 multi-tier system. We implement our technique in a tool
                 for Java applications using JDBC and experimentally
                 validate it using the multi-tier component of the
                 Dacapo benchmark.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '12 conference proceedings.",
}

@Article{Tardieu:2012:WSS,
  author =       "Olivier Tardieu and Haichuan Wang and Haibo Lin",
  title =        "A work-stealing scheduler for {X10}'s task parallelism
                 with suspension",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "8",
  pages =        "267--276",
  month =        aug,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2370036.2145850",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Wed Sep 12 12:11:57 MDT 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "PPOPP '12 conference proceedings.",
  abstract =     "The X10 programming language is intended to ease the
                 programming of scalable concurrent and distributed
                 applications. X10 augments a familiar imperative
                 object-oriented programming model with constructs to
                 support light-weight asynchronous tasks as well as
                 execution across multiple address spaces. A crucial
                 aspect of X10's runtime system is the scheduling of
                 concurrent tasks. Work-stealing schedulers have been
                 shown to efficiently load balance fine-grain
                 divide-and-conquer task-parallel program on SMPs and
                 multicores. But X10 is not limited to shared-memory
                 fork-join parallelism. X10 permits tasks to suspend and
                 synchronize by means of conditional atomic blocks and
                 remote task invocations. In this paper, we demonstrate
                 that work-stealing scheduling principles are applicable
                 to a rich programming language such as X10, achieving
                 performance at scale without compromising expressivity,
                 ease of use, or portability. We design and implement a
                 portable work-stealing execution engine for X10. While
                 this engine is biased toward the efficient execution of
                 fork-join parallelism in shared memory, it handles the
                 full X10 language, especially conditional atomic blocks
                 and distribution. We show that this engine improves the
                 run time of a series of benchmark programs by several
                 orders of magnitude when used in combination with the
                 C++ backend compiler and runtime for X10. It achieves
                 scaling comparable to state-of-the art work-stealing
                 scheduler implementations---the Cilk++ compiler and the
                 Java fork/join framework---despite the dramatic
                 increase in generality.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Teodorovici:2012:BRC,
  author =       "Vasile G. Teodorovici",
  title =        "Book Review: {{\booktitle{Continuous testing with
                 Ruby, Rails and JavaScript}} by Ben Rady and Rod
                 Coffin}",
  journal =      j-SIGSOFT,
  volume =       "37",
  number =       "1",
  pages =        "36--36",
  month =        jan,
  year =         "2012",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/2088883.2088906",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:16:09 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Toegl:2012:SSJ,
  author =       "Ronald Toegl and Thomas Winkler and Mohammad Nauman
                 and Theodore W. Hong",
  title =        "Specification and Standardization of a {Java Trusted
                 Computing API}",
  journal =      j-SPE,
  volume =       "42",
  number =       "8",
  pages =        "945--965",
  month =        aug,
  year =         "2012",
  CODEN =        "SPEXBL",
  DOI =          "https://doi.org/10.1002/spe.1095",
  ISSN =         "0038-0644 (print), 1097-024X (electronic)",
  ISSN-L =       "0038-0644",
  bibdate =      "Tue Nov 6 17:14:12 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/spe.bib;
                 http://www3.interscience.wiley.com/journalfinder.html",
  acknowledgement = ack-nhfb,
  fjournal =     "Software---Practice and Experience",
  journal-URL =  "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)1097-024X",
  onlinedate =   "13 Jul 2011",
}

@Article{Toledo:2012:AJA,
  author =       "R. Toledo and A. Nunez and E. Tanter and J. Noye",
  title =        "Aspectizing {Java} Access Control",
  journal =      j-IEEE-TRANS-SOFTW-ENG,
  volume =       "38",
  number =       "1",
  pages =        "101--117",
  month =        jan # "\slash " # feb,
  year =         "2012",
  CODEN =        "IESEDJ",
  DOI =          "https://doi.org/10.1109/TSE.2011.6",
  ISSN =         "0098-5589 (print), 1939-3520 (electronic)",
  ISSN-L =       "0098-5589",
  bibdate =      "Thu Feb 1 19:49:24 MST 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ieeetranssoftweng2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=5680915",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE Transactions on Software Engineering",
  journal-URL =  "http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=32",
}

@Article{vanderMerwe:2012:VAA,
  author =       "Heila van der Merwe and Brink van der Merwe and Willem
                 Visser",
  title =        "Verifying {Android} applications using {Java
                 PathFinder}",
  journal =      j-SIGSOFT,
  volume =       "37",
  number =       "6",
  pages =        "1--5",
  month =        nov,
  year =         "2012",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/2382756.2382797",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:16:18 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  abstract =     "Mobile application testing is a specialised and
                 complex field. Due to mobile applications' event driven
                 design and mobile runtime environment, there currently
                 exist only a small number of tools to verify these
                 applications. This paper describes the development of
                 JPF-ANDROID, an Android application verification tool.
                 JPF-ANDROID is built on Java Pathfinder, a Java model
                 checking engine. JPF-ANDROID provides a simplified
                 model of the Android framework on which an Android
                 application can run. It then allows the user to script
                 input events to drive the application flow. JPF-ANDROID
                 provides a way to detect common property violations
                 such as deadlocks and runtime exceptions in Android
                 applications.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Vitek:2012:ISI,
  author =       "Jan Vitek and Tomas Kalibera",
  title =        "Introduction to the {Special Issue on Java
                 Technologies for Real-Time and Embedded Systems}",
  journal =      j-CCPE,
  volume =       "24",
  number =       "8",
  pages =        "751--752",
  month =        "????",
  year =         "2012",
  CODEN =        "CCPEBO",
  DOI =          "https://doi.org/10.1002/cpe.1769",
  ISSN =         "1532-0626 (print), 1532-0634 (electronic)",
  ISSN-L =       "1532-0626",
  bibdate =      "Sat May 26 08:11:47 MDT 2012",
  bibsource =    "http://www.interscience.wiley.com/jpages/1532-0626;
                 https://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Concurrency and Computation: Prac\-tice and
                 Experience",
  journal-URL =  "http://www.interscience.wiley.com/jpages/1532-0626",
  onlinedate =   "23 Jun 2011",
}

@Article{Walker:2012:SNJ,
  author =       "Henry M. Walker",
  title =        "{SIGCSE} by the numbers: {JavaScript}",
  journal =      j-SIGCSE,
  volume =       "44",
  number =       "1",
  pages =        "8--8",
  month =        jan,
  year =         "2012",
  CODEN =        "SIGSD3",
  DOI =          "https://doi.org/10.1145/2132499.2132502",
  ISSN =         "0097-8418 (print), 2331-3927 (electronic)",
  ISSN-L =       "0097-8418",
  bibdate =      "Sat Nov 17 15:44:30 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigcse2010.bib",
  abstract =     "As you may know, SIGCSE 2000 was the first SIGCSE
                 conference that utilized an online system for the
                 submission and reviewing of papers. Naively, for that
                 first conference, I relied upon JavaScript for error
                 checking, so I assumed error checking was not needed at
                 the server --- after all, checking had already been
                 done by the browser, right?",
  acknowledgement = ack-nhfb,
  fjournal =     "SIGCSE Bulletin (ACM Special Interest Group on
                 Computer Science Education)",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J688",
}

@Article{Wellings:2012:AEH,
  author =       "Andy Wellings and MinSeong Kim",
  title =        "Asynchronous event handling and {Safety Critical
                 Java}",
  journal =      j-CCPE,
  volume =       "24",
  number =       "8",
  pages =        "813--832",
  month =        "????",
  year =         "2012",
  CODEN =        "CCPEBO",
  DOI =          "https://doi.org/10.1002/cpe.1756",
  ISSN =         "1532-0626 (print), 1532-0634 (electronic)",
  ISSN-L =       "1532-0626",
  bibdate =      "Sat May 26 08:11:47 MDT 2012",
  bibsource =    "http://www.interscience.wiley.com/jpages/1532-0626;
                 https://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Concurrency and Computation: Prac\-tice and
                 Experience",
  journal-URL =  "http://www.interscience.wiley.com/jpages/1532-0626",
  onlinedate =   "1 May 2011",
}

@Article{Xi:2012:MDA,
  author =       "Kai Xi and Jiankun Hu and Fengling Han",
  title =        "Mobile device access control: an improved correlation
                 based face authentication scheme and its {Java ME}
                 application",
  journal =      j-CCPE,
  volume =       "24",
  number =       "10",
  pages =        "1066--1085",
  month =        jul,
  year =         "2012",
  CODEN =        "CCPEBO",
  DOI =          "https://doi.org/10.1002/cpe.1797",
  ISSN =         "1532-0626 (print), 1532-0634 (electronic)",
  ISSN-L =       "1532-0626",
  bibdate =      "Mon Nov 5 07:44:49 MST 2012",
  bibsource =    "http://www.interscience.wiley.com/jpages/1532-0626;
                 https://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 https://www.math.utah.edu/pub/tex/bib/cryptography2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Concurrency and Computation: Practice and Experience",
  journal-URL =  "http://www.interscience.wiley.com/jpages/1532-0626",
  onlinedate =   "28 Jul 2011",
}

@Article{Xue:2012:RJC,
  author =       "Jingling Xue",
  title =        "Rethinking {Java} call stack design for tiny embedded
                 devices",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "5",
  pages =        "1--10",
  month =        may,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2345141.2248420",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Aug 6 16:31:46 MDT 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  note =         "LCTES '12 proceedings.",
  abstract =     "The ability of tiny embedded devices to run large
                 feature-rich programs is typically constrained by the
                 amount of memory installed on such devices.
                 Furthermore, the useful operation of these devices in
                 wireless sensor applications is limited by their
                 battery life. This paper presents a call stack redesign
                 targeted at an efficient use of RAM storage and CPU
                 cycles by a Java program running on a wireless sensor
                 mote. Without compromising the application programs,
                 our call stack redesign saves 30\% of RAM, on average,
                 evaluated over a large number of benchmarks. On the
                 same set of bench-marks, our design also avoids
                 frequent RAM allocations and deallocations, resulting
                 in average 80\% fewer memory operations and 23\% faster
                 program execution. These may be critical improvements
                 for tiny embedded devices that are equipped with small
                 amount of RAM and limited battery life. However, our
                 call stack redesign is equally effective for any
                 complex multi-threaded object oriented program
                 developed for desktop computers. We describe the
                 redesign, measure its performance and report the
                 resulting savings in RAM and execution time for a wide
                 variety of programs.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Yang:2012:MPD,
  author =       "Cheng-Hong Yang and Yu-Huei Cheng and Cheng-Huei Yang
                 and Li-Yeh Chuang",
  title =        "Mutagenic Primer Design for Mismatch {PCR-RFLP} {SNP}
                 Genotyping Using a Genetic Algorithm",
  journal =      j-TCBB,
  volume =       "9",
  number =       "3",
  pages =        "837--845",
  month =        may,
  year =         "2012",
  CODEN =        "ITCBCY",
  DOI =          "https://doi.org/10.1109/TCBB.2012.25",
  ISSN =         "1545-5963 (print), 1557-9964 (electronic)",
  ISSN-L =       "1545-5963",
  bibdate =      "Thu Apr 19 17:58:10 MDT 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/tcbb.bib",
  abstract =     "Polymerase chain reaction-restriction fragment length
                 polymorphism (PCR-RFLP) is useful in small-scale basic
                 research studies of complex genetic diseases that are
                 associated with single nucleotide polymorphism (SNP).
                 Designing a feasible primer pair is an important work
                 before performing PCR-RFLP for SNP genotyping. However,
                 in many cases, restriction enzymes to discriminate the
                 target SNP resulting in the primer design is not
                 applicable. A mutagenic primer is introduced to solve
                 this problem. GA-based Mismatch PCR-RFLP Primers Design
                 (GAMPD) provides a method that uses a genetic algorithm
                 to search for optimal mutagenic primers and available
                 restriction enzymes from REBASE. In order to improve
                 the efficiency of the proposed method, a mutagenic
                 matrix is employed to judge whether a hypothetical
                 mutagenic primer can discriminate the target SNP by
                 digestion with available restriction enzymes. The
                 available restriction enzymes for the target SNP are
                 mined by the updated core of SNP-RFLPing. GAMPD has
                 been used to simulate the SNPs in the human SLC6A4 gene
                 under different parameter settings and compared with
                 SNP Cutter for mismatch PCR-RFLP primer design. The in
                 silico simulation of the proposed GAMPD program showed
                 that it designs mismatch PCR-RFLP primers. The GAMPD
                 program is implemented in JAVA and is freely available
                 at http://bio.kuas.edu.tw/gampd/",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE/ACM Transactions on Computational Biology and
                 Bioinformatics",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J954",
}

@Article{Yerima:2012:AMB,
  author =       "Suleiman Y. Yerima and Gerard P. Parr and Sally I.
                 McClean and Philip J. Morrow",
  title =        "Adaptive Measurement-Based Policy-Driven {QoS}
                 Management with Fuzzy-Rule-based Resource Allocation",
  journal =      j-FUTURE-INTERNET,
  volume =       "4",
  number =       "3",
  pages =        "646--671",
  day =          "04",
  month =        jul,
  year =         "2012",
  CODEN =        "????",
  DOI =          "https://doi.org/10.3390/fi4030646",
  ISSN =         "1999-5903",
  bibdate =      "Thu Nov 21 16:50:48 MST 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/future-internet.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "https://www.mdpi.com/1999-5903/4/3/646",
  abstract =     "Fixed and wireless networks are increasingly
                 converging towards common connectivity with IP-based
                 core networks. Providing effective end-to-end resource
                 and QoS management in such complex heterogeneous
                 converged network scenarios requires unified, adaptive
                 and scalable solutions to integrate and co-ordinate
                 diverse QoS mechanisms of different access technologies
                 with IP-based QoS. Policy-Based Network Management
                 (PBNM) is one approach that could be employed to
                 address this challenge. Hence, a policy-based framework
                 for end-to-end QoS management in converged networks,
                 CNQF (Converged Networks QoS Management Framework) has
                 been proposed within our project. In this paper, the
                 CNQF architecture, a Java implementation of its
                 prototype and experimental validation of key elements
                 are discussed. We then present a fuzzy-based CNQF
                 resource management approach and study the performance
                 of our implementation with real traffic flows on an
                 experimental testbed. The results demonstrate the
                 efficacy of our resource-adaptive approach for
                 practical PBNM systems.",
  acknowledgement = ack-nhfb,
  remark =       "Special Issue Selected Papers from ITA 11.",
}

@Book{Zakhour:2012:JTS,
  author =       "Sharon Zakhour",
  title =        "The {Java} tutorial: a short course on the basics",
  publisher =    pub-PH,
  address =      pub-PH:adr,
  edition =      "Fifth",
  pages =        "????",
  year =         "2012",
  ISBN =         "0-13-276169-6 (paperback)",
  ISBN-13 =      "978-0-13-276169-7 (paperback)",
  LCCN =         "????",
  bibdate =      "Mon Jan 28 14:57:26 MST 2013",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  subject =      "Java (Computer program language); Object-oriented
                 programming (Computer science)",
}

@Article{Zhang:2012:RAJ,
  author =       "Ying Zhang and Gang Huang and Xuanzhe Liu and Wei
                 Zhang and Hong Mei and Shunxiang Yang",
  title =        "Refactoring {Android Java} code for on-demand
                 computation offloading",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "10",
  pages =        "233--248",
  month =        oct,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2398857.2384634",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Nov 15 16:40:23 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Computation offloading is a promising way to improve
                 the performance as well as reducing the battery power
                 consumption of a smartphone application by executing
                 some parts of the application on a remote server.
                 Supporting such capability is not easy for smartphone
                 application developers due to (1) correctness: some
                 code, e.g., that for GPS, gravity, and other sensors,
                 can run only on the smartphone so that developers have
                 to identify which parts of the application cannot be
                 offloaded; (2) effectiveness: the reduced execution
                 time must be greater than the network delay caused by
                 computation offloading so that developers need to
                 calculate which parts are worth offloading; (3)
                 adaptability: smartphone applications often face
                 changes of user requirements and runtime environments
                 so that developers need to implement the adaptation on
                 offloading. More importantly, considering the large
                 number of today's smartphone applications, solutions
                 applicable for legacy applications will be much more
                 valuable. In this paper, we present a tool, named
                 DPartner, that automatically refactors Android
                 applications to be the ones with computation offloading
                 capability. For a given Android application, DPartner
                 first analyzes its bytecode for discovering the parts
                 worth offloading, then rewrites the bytecode to
                 implement a special program structure supporting
                 on-demand offloading, and finally generates two
                 artifacts to be deployed onto an Android phone and the
                 server, respectively. We evaluated DPartner on three
                 real-world Android applications, demonstrating the
                 reduction of execution time by 46\%-97\% and battery
                 power consumption by 27\%-83\%.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '12 conference proceedings.",
}

@Article{Zhang:2012:SRB,
  author =       "Yuan Zhang and Min Yang and Bo Zhou and Zhemin Yang
                 and Weihua Zhang and Binyu Zang",
  title =        "{Swift}: a register-based {JIT} compiler for embedded
                 {JVMs}",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "7",
  pages =        "63--74",
  month =        jul,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2365864.2151035",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Sep 6 10:01:03 MDT 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "VEE '12 conference proceedings.",
  abstract =     "Code quality and compilation speed are two challenges
                 to JIT compilers, while selective compilation is
                 commonly used to trade-off these two issues. Meanwhile,
                 with more and more Java applications running in mobile
                 devices, selective compilation meets many problems.
                 Since these applications always have flat execution
                 profile and short live time, a lightweight JIT
                 technique without losing code quality is extremely
                 needed. However, the overhead of compiling stack-based
                 Java bytecode to heterogeneous register-based machine
                 code is significant in embedded devices. This paper
                 presents a fast and effective JIT technique for mobile
                 devices, building on a register-based Java bytecode
                 format which is more similar to the underlying machine
                 architecture. Through a comprehensive study on the
                 characteristics of Java applications, we observe that
                 virtual registers used by more than 90\% Java methods
                 can be directly fulfilled by 11 physical registers.
                 Based on this observation, this paper proposes Swift, a
                 novel JIT compiler on register-based bytecode, which
                 generates native code for RISC machines. After mapping
                 virtual registers to physical registers, the code is
                 generated efficiently by looking up a translation
                 table. And the code quality is guaranteed by the static
                 compiler which is used to generate register-based
                 bytecode. Besides, we design two lightweight
                 optimizations and an efficient code unloader to make
                 Swift more suitable for embedded environment. As the
                 prevalence of Android, a prototype of Swift is
                 implemented upon DEX bytecode which is the official
                 distribution format of Android applications. Swift is
                 evaluated with three benchmarks (SPECjvm98,
                 EmbeddedCaffeineMark3 and JemBench2) on two different
                 ARM SOCs: S3C6410 (armv6) and OMAP3530 (armv7). The
                 results show that Swift achieves a speedup of 3.13 over
                 the best-performing interpreter on the selected
                 benchmarks. Compared with the state-of-the-art JIT
                 compiler in Android, JITC-Droid, Swift achieves a
                 speedup of 1.42.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Zhao:2012:PTI,
  author =       "Tian Zhao",
  title =        "Polymorphic type inference for scripting languages
                 with object extensions",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "2",
  pages =        "37--50",
  month =        feb,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2168696.2047855",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Apr 20 17:34:09 MDT 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "This paper presents a polymorphic type inference
                 algorithm for a small subset of JavaScript. The goal is
                 to prevent accessing undefined members of objects. We
                 define a type system that allows explicit extension of
                 objects through add operation and implicit extension
                 through method calls. The type system also permits
                 strong updates and unrestricted extensions to new
                 objects. The type inference algorithm is modular so
                 that each function definition is only analyzed once and
                 larger programs can be checked incrementally.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "DSL '11 conference proceedings.",
}

@Article{Akgun:2013:PEP,
  author =       "Devrim Akgun",
  title =        "Performance Evaluations for Parallel Image Filter on
                 Multi-Core Computer using {Java} Threads",
  journal =      j-INT-J-COMP-APPL,
  volume =       "74",
  number =       "??",
  pages =        "13--19",
  month =        jul,
  year =         "2013",
  CODEN =        "????",
  DOI =          "https://doi.org/10.5120/12928-9836",
  ISSN =         "0975-8887",
  ISSN-L =       "0975-8887",
  bibdate =      "Fri Jan 24 08:59:22 MST 2025",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/intjcompappl.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "https://www.ijcaonline.org/archives/volume74/number11/12928-9836/",
  acknowledgement = ack-nhfb,
  ajournal =     "Intern. J. of Computer Applications",
  articleno =    "11",
  fjournal =     "International Journal of Computer Applications",
  journal-URL =  "https://www.ijcaonline.org/",
}

@Book{Ament:2013:ATG,
  author =       "John Ament",
  title =        "{Arquillian} Testing Guide: get familiarized with the
                 {Arquillian} framework and its capabilities to carry
                 out integration and functional testing on a {Java}
                 virtual machine",
  publisher =    "Packt Publishing",
  address =      "Birmingham, UK",
  pages =        "v + 224",
  year =         "2013",
  ISBN =         "1-78216-070-1",
  ISBN-13 =      "978-1-78216-070-0",
  LCCN =         "QA76.73.J3",
  bibdate =      "Thu Dec 4 08:31:46 MST 2014",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  URL =          "http://proquest.tech.safaribooksonline.de/9781782160700",
  acknowledgement = ack-nhfb,
}

@Article{Anonymous:2013:FAM,
  author =       "Anonymous",
  title =        "{Facebook}, {Apple} and {Microsoft} hit by {Java}
                 exploit at watering hole",
  journal =      j-NETWORK-SECURITY,
  volume =       "2013",
  number =       "3",
  pages =        "1--2",
  month =        mar,
  year =         "2013",
  CODEN =        "NTSCF5",
  DOI =          "https://doi.org/10.1016/S1353-4858(13)70035-7",
  ISSN =         "1353-4858 (print), 1872-9371 (electronic)",
  ISSN-L =       "1353-4858",
  bibdate =      "Mon Dec 4 17:00:52 MST 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/network-security.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S1353485813700357",
  acknowledgement = ack-nhfb,
  fjournal =     "Network Security",
  journal-URL =  "https://www.sciencedirect.com/journal/network-security",
}

@Article{Autili:2013:HAR,
  author =       "Marco Autili and Paolo {Di Benedetto} and Paola
                 Inverardi",
  title =        "A hybrid approach for resource-based comparison of
                 adaptable {Java} applications",
  journal =      j-SCI-COMPUT-PROGRAM,
  volume =       "78",
  number =       "8",
  pages =        "987--1009",
  day =          "1",
  month =        aug,
  year =         "2013",
  CODEN =        "SCPGD4",
  ISSN =         "0167-6423 (print), 1872-7964 (electronic)",
  ISSN-L =       "0167-6423",
  bibdate =      "Tue Sep 3 06:34:35 MDT 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/scicomputprogram.bib;
                 http://www.sciencedirect.com/science/journal/01676423",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0167642312000147",
  acknowledgement = ack-nhfb,
  fjournal =     "Science of Computer Programming",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01676423",
}

@Article{Axelsen:2013:PTD,
  author =       "Eyvind W. Axelsen and Stein Krogdahl",
  title =        "{Package Templates}: a definition by
                 semantics-preserving source-to-source transformations
                 to efficient {Java} code",
  journal =      j-SIGPLAN,
  volume =       "48",
  number =       "3",
  pages =        "50--59",
  month =        mar,
  year =         "2013",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2480361.2371409",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Jul 1 17:15:18 MDT 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Package Templates (PT) is a mechanism designed for
                 writing reusable modules, called templates, each
                 consisting of a set of classes that can be adapted to
                 their use in a program through compile-time
                 specialization. A template must be instantiated in a
                 program before its classes can be used. The mechanism
                 supports type-safe renaming, merging, type
                 parameterization and refinement in the form of static
                 additions and overrides that are orthogonal to the
                 corresponding concepts of ordinary inheritance. In this
                 paper, we consider PT as an extension to Java, and a PT
                 program will then consist of a number of Java packages
                 and templates, where templates are instantiated in
                 packages or other templates. Our aim and main
                 contribution is to define the meaning of such a
                 program, and to show that this definition is
                 consistent. We first show this for a core subset of PT,
                 C-PT, and define a set of source-to-source
                 transformations for converting C-PT programs to plain
                 Java programs using semantics we have described
                 informally in previous papers. We can then define the
                 meaning of a C-PT program in terms of the resulting
                 Java program. Thus, we have to verify that the
                 transformations will always convert a legal C-PT
                 program to a legal Java program. Finally, we briefly
                 discuss how this approach can be extended to full PT. A
                 main challenge is to preserve externally visible names
                 (for classes, methods and fields), and at the same time
                 prevent unwanted subsequent rebindings caused e.g. by
                 over-load resolution in the Java compiler. Names that
                 are bound to declarations in a template should not be
                 rebound to different declarations by subsequent
                 compositions or adaptions. In addition to defining the
                 runtime semantics of PT constructs in terms of their
                 translation to Java, the transformation rules can also
                 be seen as a high-level approach to how a compiler for
                 this language might be implemented.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "GPCE '12 conference proceedings.",
}

@Article{Bacon:2013:PRT,
  author =       "David F. Bacon and Perry Cheng and V. T. Rajan",
  title =        "{POPL 2003}: a real-time garbage collector with low
                 overhead and consistent utilization",
  journal =      j-SIGPLAN,
  volume =       "48",
  number =       "4S",
  pages =        "58--71",
  month =        apr,
  year =         "2013",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2502508.2502523",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Jul 15 15:53:11 MDT 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Now that the use of garbage collection in languages
                 like Java is becoming widely accepted due to the safety
                 and software engineering benefits it provides, there is
                 significant interest in applying garbage collection to
                 hard real-time systems. Past approaches have generally
                 suffered from one of two major flaws: either they were
                 not provably real-time, or they imposed large space
                 overheads to meet the real-time bounds. We present a
                 mostly non-moving, dynamically defragmenting collector
                 that overcomes both of these limitations: by avoiding
                 copying in most cases, space requirements are kept low;
                 and by fully incrementalizing the collector we are able
                 to meet real-time bounds. We implemented our algorithm
                 in the Jikes RVM and show that at real-time resolution
                 we are able to obtain mutator utilization rates of 45\%
                 with only 1.6--2.5 times the actual space required by
                 the application, a factor of 4 improvement in
                 utilization over the best previously published results.
                 Defragmentation causes no more than 4\% of the traced
                 data to be copied.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Bainomugisha:2013:SRP,
  author =       "Engineer Bainomugisha and Andoni Lombide Carreton and
                 Tom van Cutsem and Stijn Mostinckx and Wolfgang de
                 Meuter",
  title =        "A survey on reactive programming",
  journal =      j-COMP-SURV,
  volume =       "45",
  number =       "4",
  pages =        "52:1--52:??",
  month =        aug,
  year =         "2013",
  CODEN =        "CMSVAN",
  DOI =          "https://doi.org/10.1145/2501654.2501666",
  ISSN =         "0360-0300 (print), 1557-7341 (electronic)",
  ISSN-L =       "0360-0300",
  bibdate =      "Mon Aug 26 17:21:41 MDT 2013",
  bibsource =    "http://www.acm.org/pubs/contents/journals/surveys/;
                 https://www.math.utah.edu/pub/tex/bib/compsurv.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "Reactive programming has recently gained popularity as
                 a paradigm that is well-suited for developing
                 event-driven and interactive applications. It
                 facilitates the development of such applications by
                 providing abstractions to express time-varying values
                 and automatically managing dependencies between such
                 values. A number of approaches have been recently
                 proposed embedded in various languages such as Haskell,
                 Scheme, JavaScript, Java, .NET, etc. This survey
                 describes and provides a taxonomy of existing reactive
                 programming approaches along six axes: representation
                 of time-varying values, evaluation model, lifting
                 operations, multidirectionality, glitch avoidance, and
                 support for distribution. From this taxonomy, we
                 observe that there are still open challenges in the
                 field of reactive programming. For instance,
                 multidirectionality is supported only by a small number
                 of languages, which do not automatically track
                 dependencies between time-varying values. Similarly,
                 glitch avoidance, which is subtle in reactive programs,
                 cannot be ensured in distributed reactive programs
                 using the current techniques.",
  acknowledgement = ack-nhfb,
  articleno =    "52",
  fjournal =     "ACM Computing Surveys",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J204",
}

@Article{Balatsouras:2013:CHC,
  author =       "George Balatsouras and Yannis Smaragdakis",
  title =        "Class hierarchy complementation: soundly completing a
                 partial type graph",
  journal =      j-SIGPLAN,
  volume =       "48",
  number =       "10",
  pages =        "515--532",
  month =        oct,
  year =         "2013",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2544173.2509530",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Dec 9 09:19:33 MST 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "OOPSLA '13 conference proceedings.",
  abstract =     "We present the problem of class hierarchy
                 complementation: given a partially known hierarchy of
                 classes together with subtyping constraints (``A has to
                 be a transitive subtype of B'') complete the hierarchy
                 so that it satisfies all constraints. The problem has
                 immediate practical application to the analysis of
                 partial programs--e.g., it arises in the process of
                 providing a sound handling of ``phantom classes'' in
                 the Soot program analysis framework. We provide
                 algorithms to solve the hierarchy complementation
                 problem in the single inheritance and multiple
                 inheritance settings. We also show that the problem in
                 a language such as Java, with single inheritance but
                 multiple subtyping and distinguished class vs.
                 interface types, can be decomposed into separate
                 single- and multiple-subtyping instances. We implement
                 our algorithms in a tool, JPhantom, which complements
                 partial Java bytecode programs so that the result is
                 guaranteed to satisfy the Java verifier requirements.
                 JPhantom is highly scalable and runs in mere seconds
                 even for large input applications and complex
                 constraints (with a maximum of 14s for a 19MB
                 binary).",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Basanta-Val:2013:JRA,
  author =       "P. Basanta-Val and M. Garc{\'\i}a-Valls and I.
                 Est{\'e}vez-Ayres",
  title =        "Enhancing {OSGi} with real-time {Java} support",
  journal =      j-SPE,
  volume =       "43",
  number =       "1",
  pages =        "33--65",
  month =        jan,
  year =         "2013",
  CODEN =        "SPEXBL",
  DOI =          "https://doi.org/10.1002/spe.2101",
  ISSN =         "0038-0644 (print), 1097-024X (electronic)",
  ISSN-L =       "0038-0644",
  bibdate =      "Fri Dec 21 11:42:46 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/spe.bib;
                 http://www3.interscience.wiley.com/journalfinder.html",
  acknowledgement = ack-nhfb,
  fjournal =     "Software---Practice and Experience",
  journal-URL =  "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)1097-024X",
  onlinedate =   "29 Jan 2012",
}

@Article{Bedi:2013:MMT,
  author =       "Punam Bedi and Vandana Gandotra and Archana Singhal
                 and Himanshi Narang and Sumit Sharma",
  title =        "Mitigating multi-threats optimally in proactive threat
                 management",
  journal =      j-SIGSOFT,
  volume =       "38",
  number =       "1",
  pages =        "1--7",
  month =        jan,
  year =         "2013",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/2413038.2413041",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:16:22 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  abstract =     "In turbulent economic times, the cost effectiveness of
                 security measures is of the utmost importance when
                 designing safeguards or countermeasures. This paper
                 presents an optimal approach: MMT-O, Mitigating
                 Multi-Threats Optimally, to meet the above challenges.
                 The proposed approach is based on an optimum mitigation
                 path set generation algorithm that provides optimal
                 plans for threat/vulnerability management which can be
                 adopted at the design level of the software life cycle.
                 In MMT-O, a multi-threat attack graph is generated by
                 combining all of the individual threats responsible for
                 security compromise of the system. It identifies a
                 unique set of attacks needing mitigation by removing
                 redundant nodes, as an attack can be a part of multiple
                 threats. The proposed algorithm, implemented in Java,
                 provides the minimum mitigation paths required to be
                 blocked to avert the threat. Countermeasures using a
                 multi-agent system are inducted in these identified
                 mitigation paths to avert the threat optimally. The
                 proposed approach has been applied on different test
                 cases and the results validate its economic
                 justification over traditional security solutions as a
                 part of proactive threat management.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Bellia:2013:JST,
  author =       "Marco Bellia and M. Eugenia Occhiuto",
  title =        "{Java} {SAM} Typed Closures: A Sound and Complete Type
                 Inference System for Nominal Types",
  journal =      j-FUND-INFO,
  volume =       "128",
  number =       "1--2",
  pages =        "17--33",
  month =        jan,
  year =         "2013",
  CODEN =        "FUMAAJ",
  DOI =          "https://doi.org/10.3233/FI-2013-930",
  ISSN =         "0169-2968 (print), 1875-8681 (electronic)",
  ISSN-L =       "0169-2968",
  bibdate =      "Sat Mar 5 17:17:45 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/fundinfo2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Fundamenta Informaticae",
  journal-URL =  "http://content.iospress.com/journals/fundamenta-informaticae",
}

@Article{Bettini:2013:CTB,
  author =       "Lorenzo Bettini and Ferruccio Damiani and Kathrin
                 Geilmann and Jan Sch{\"a}fer",
  title =        "Combining traits with boxes and ownership types in a
                 {Java}-like setting",
  journal =      j-SCI-COMPUT-PROGRAM,
  volume =       "78",
  number =       "2",
  pages =        "218--247",
  day =          "1",
  month =        feb,
  year =         "2013",
  CODEN =        "SCPGD4",
  DOI =          "https://doi.org/10.1016/j.scico.2011.10.006",
  ISSN =         "0167-6423 (print), 1872-7964 (electronic)",
  ISSN-L =       "0167-6423",
  bibdate =      "Fri Nov 16 06:35:12 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/scicomputprogram.bib;
                 http://www.sciencedirect.com/science/journal/01676423",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0167642311001833",
  acknowledgement = ack-nhfb,
  fjournal =     "Science of Computer Programming",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01676423",
}

@Article{Bettini:2013:FDT,
  author =       "Lorenzo Bettini and Sara Capecchi and Ferruccio
                 Damiani",
  title =        "On flexible dynamic trait replacement for {Java}-like
                 languages",
  journal =      j-SCI-COMPUT-PROGRAM,
  volume =       "78",
  number =       "7",
  pages =        "907--932",
  day =          "1",
  month =        jul,
  year =         "2013",
  CODEN =        "SCPGD4",
  ISSN =         "0167-6423 (print), 1872-7964 (electronic)",
  ISSN-L =       "0167-6423",
  bibdate =      "Mon May 13 13:51:09 MDT 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/scicomputprogram.bib;
                 http://www.sciencedirect.com/science/journal/01676423",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0167642312002092",
  acknowledgement = ack-nhfb,
  fjournal =     "Science of Computer Programming",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01676423",
}

@Article{Bodden:2013:SLS,
  author =       "Eric Bodden and T{\'a}rsis Tol{\^e}do and M{\'a}rcio
                 Ribeiro and Claus Brabrand and Paulo Borba and Mira
                 Mezini",
  title =        "{SPL LIFT}: statically analyzing software product
                 lines in minutes instead of years",
  journal =      j-SIGPLAN,
  volume =       "48",
  number =       "6",
  pages =        "355--364",
  month =        jun,
  year =         "2013",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2499370.2491976",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Jul 1 17:15:38 MDT 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "A software product line (SPL) encodes a potentially
                 large variety of software products as variants of some
                 common code base. Up until now, re-using traditional
                 static analyses for SPLs was virtually intractable, as
                 it required programmers to generate and analyze all
                 products individually. In this work, however, we show
                 how an important class of existing inter-procedural
                 static analyses can be transparently lifted to SPLs.
                 Without requiring programmers to change a single line
                 of code, our approach SPLLIFT automatically converts
                 any analysis formulated for traditional programs within
                 the popular IFDS framework for inter-procedural,
                 finite, distributive, subset problems to an SPL-aware
                 analysis formulated in the IDE framework, a well-known
                 extension to IFDS. Using a full implementation based on
                 Heros, Soot, CIDE and JavaBDD, we show that with
                 SPLLIFT one can reuse IFDS-based analyses without
                 changing a single line of code. Through experiments
                 using three static analyses applied to four Java-based
                 product lines, we were able to show that our approach
                 produces correct results and outperforms the
                 traditional approach by several orders of magnitude.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "PLDI '13 conference proceedings.",
}

@Article{Bois:2013:BGV,
  author =       "Kristof {Du Bois} and Jennifer B. Sartor and Stijn
                 Eyerman and Lieven Eeckhout",
  title =        "Bottle graphs: visualizing scalability bottlenecks in
                 multi-threaded applications",
  journal =      j-SIGPLAN,
  volume =       "48",
  number =       "10",
  pages =        "355--372",
  month =        oct,
  year =         "2013",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2544173.2509529",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Dec 9 09:19:33 MST 2013",
  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/sigplan2010.bib",
  note =         "OOPSLA '13 conference proceedings.",
  abstract =     "Understanding and analyzing multi-threaded program
                 performance and scalability is far from trivial, which
                 severely complicates parallel software development and
                 optimization. In this paper, we present bottle graphs,
                 a powerful analysis tool that visualizes multi-threaded
                 program performance, in regards to both per-thread
                 parallelism and execution time. Each thread is
                 represented as a box, with its height equal to the
                 share of that thread in the total program execution
                 time, its width equal to its parallelism, and its area
                 equal to its total running time. The boxes of all
                 threads are stacked upon each other, leading to a stack
                 with height equal to the total program execution time.
                 Bottle graphs show exactly how scalable each thread is,
                 and thus guide optimization towards those threads that
                 have a smaller parallel component (narrower), and a
                 larger share of the total execution time (taller), i.e.
                 to the 'neck' of the bottle. Using light-weight OS
                 modules, we calculate bottle graphs for unmodified
                 multi-threaded programs running on real processors with
                 an average overhead of 0.68\%. To demonstrate their
                 utility, we do an extensive analysis of 12 Java
                 benchmarks running on top of the Jikes JVM, which
                 introduces many JVM service threads. We not only reveal
                 and explain scalability limitations of several
                 well-known Java benchmarks; we also analyze the reasons
                 why the garbage collector itself does not scale, and in
                 fact performs optimally with two collector threads for
                 all benchmarks, regardless of the number of application
                 threads. Finally, we compare the scalability of Jikes
                 versus the OpenJDK JVM. We demonstrate how useful and
                 intuitive bottle graphs are as a tool to analyze
                 scalability and help optimize multi-threaded
                 applications.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Bond:2013:OCC,
  author =       "Michael D. Bond and Milind Kulkarni and Man Cao and
                 Minjia Zhang and Meisam Fathi Salmi and Swarnendu
                 Biswas and Aritra Sengupta and Jipeng Huang",
  title =        "{OCTET}: capturing and controlling cross-thread
                 dependences efficiently",
  journal =      j-SIGPLAN,
  volume =       "48",
  number =       "10",
  pages =        "693--712",
  month =        oct,
  year =         "2013",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2544173.2509519",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Dec 9 09:19:33 MST 2013",
  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/sigplan2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  note =         "OOPSLA '13 conference proceedings.",
  abstract =     "Parallel programming is essential for reaping the
                 benefits of parallel hardware, but it is notoriously
                 difficult to develop and debug reliable, scalable
                 software systems. One key challenge is that modern
                 languages and systems provide poor support for ensuring
                 concurrency correctness properties --- atomicity,
                 sequential consistency, and multithreaded determinism
                 --- because all existing approaches are impractical.
                 Dynamic, software-based approaches slow programs by up
                 to an order of magnitude because capturing and
                 controlling cross-thread dependences (i.e., conflicting
                 accesses to shared memory) requires synchronization at
                 virtually every access to potentially shared memory.
                 This paper introduces a new software-based concurrency
                 control mechanism called OCTET that soundly captures
                 cross-thread dependences and can be used to build
                 dynamic analyses for concurrency correctness. OCTET
                 achieves low overheads by tracking the locality state
                 of each potentially shared object. Non-conflicting
                 accesses conform to the locality state and require no
                 synchronization; only conflicting accesses require a
                 state change and heavyweight synchronization. This
                 optimistic tradeoff leads to significant efficiency
                 gains in capturing cross-thread dependences: a
                 prototype implementation of OCTET in a high-performance
                 Java virtual machine slows real-world concurrent
                 programs by only 26\% on average. A dependence
                 recorder, suitable for record {\&} replay, built on top
                 of OCTET adds an additional 5\% overhead on average.
                 These results suggest that OCTET can provide a
                 foundation for developing low-overhead analyses that
                 check and enforce concurrency correctness.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Bonetta:2013:TPE,
  author =       "Daniele Bonetta and Walter Binder and Cesare
                 Pautasso",
  title =        "{TigerQuoll}: parallel event-based {JavaScript}",
  journal =      j-SIGPLAN,
  volume =       "48",
  number =       "8",
  pages =        "251--260",
  month =        aug,
  year =         "2013",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2517327.2442541",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Aug 26 13:48:51 MDT 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "PPoPP '13 Conference proceedings.",
  abstract =     "JavaScript, the most popular language on the Web, is
                 rapidly moving to the server-side, becoming even more
                 pervasive. Still, JavaScript lacks support for shared
                 memory parallelism, making it challenging for
                 developers to exploit multicores present in both
                 servers and clients. In this paper we present
                 TigerQuoll, a novel API and runtime for parallel
                 programming in JavaScript. TigerQuoll features an
                 event-based API and a parallel runtime allowing
                 applications to exploit a mutable shared memory space.
                 The programming model of TigerQuoll features automatic
                 consistency and concurrency management, such that
                 developers do not have to deal with shared-data
                 synchronization. TigerQuoll supports an innovative
                 transaction model that allows for eventual consistency
                 to speed up high-contention workloads. Experiments show
                 that TigerQuoll applications scale well, allowing one
                 to implement common parallelism patterns in
                 JavaScript.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Bu:2013:BAD,
  author =       "Yingyi Bu and Vinayak Borkar and Guoqing Xu and
                 Michael J. Carey",
  title =        "A bloat-aware design for big data applications",
  journal =      j-SIGPLAN,
  volume =       "48",
  number =       "11",
  pages =        "119--130",
  month =        nov,
  year =         "2013",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2555670.2466485",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Dec 9 08:04:34 MST 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "ISMM '13 conference proceedings.",
  abstract =     "Over the past decade, the increasing demands on
                 data-driven business intelligence have led to the
                 proliferation of large-scale, data-intensive
                 applications that often have huge amounts of data
                 (often at terabyte or petabyte scale) to process. An
                 object-oriented programming language such as Java is
                 often the developer's choice for implementing such
                 applications, primarily due to its quick development
                 cycle and rich community resource. While the use of
                 such languages makes programming easier, significant
                 performance problems can often be seen --- the
                 combination of the inefficiencies inherent in a managed
                 run-time system and the impact of the huge amount of
                 data to be processed in the limited memory space often
                 leads to memory bloat and performance degradation at a
                 surprisingly early stage. This paper proposes a
                 bloat-aware design paradigm towards the development of
                 efficient and scalable Big Data applications in
                 object-oriented GC enabled languages. To motivate this
                 work, we first perform a study on the impact of several
                 typical memory bloat patterns. These patterns are
                 summarized from the user complaints on the mailing
                 lists of two widely-used open-source Big Data
                 applications. Next, we discuss our design paradigm to
                 eliminate bloat. Using examples and real-world
                 experience, we demonstrate that programming under this
                 paradigm does not incur significant programming burden.
                 We have implemented a few common data processing tasks
                 both using this design and using the conventional
                 object-oriented design. Our experimental results show
                 that this new design paradigm is extremely effective in
                 improving performance --- even for the moderate-size
                 data sets processed, we have observed 2.5x+ performance
                 gains, and the improvement grows substantially with the
                 size of the data set.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Book{Campbell:2013:ICC,
  author =       "Bill Campbell and Swami Iyer and Bahar Akbal-Delibas",
  title =        "Introduction to compiler construction in a {Java}
                 world",
  publisher =    pub-CRC,
  address =      pub-CRC:adr,
  pages =        "????",
  year =         "2013",
  ISBN =         "1-4398-6088-2 (hardcover)",
  ISBN-13 =      "978-1-4398-6088-5 (hardcover)",
  LCCN =         "QA76.73.J38 C363 2013",
  bibdate =      "Thu Nov 15 17:16:13 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 z3950.loc.gov:7090/Voyager",
  acknowledgement = ack-nhfb,
  subject =      "Compilers (Computer programs); Java (Computer program
                 language)",
}

@Article{Carro:2013:MDA,
  author =       "Manuel Carro and {\'A}ngel Herranz and Julio
                 Mari{\~n}o",
  title =        "A model-driven approach to teaching concurrency",
  journal =      j-TOCE,
  volume =       "13",
  number =       "1",
  pages =        "5:1--5:??",
  month =        jan,
  year =         "2013",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/2414446.2414451",
  ISSN =         "1946-6226",
  bibdate =      "Sat Feb 2 06:44:42 MST 2013",
  bibsource =    "http://www.acm.org/pubs/toce;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/toce.bib",
  abstract =     "We present an undergraduate course on concurrent
                 programming where formal models are used in different
                 stages of the learning process. The main practical
                 difference with other approaches lies in the fact that
                 the ability to develop correct concurrent software
                 relies on a systematic transformation of formal models
                 of inter-process interaction (so called shared
                 resources), rather than on the specific constructs of
                 some programming language. Using a resource-centric
                 rather than a language-centric approach has some
                 benefits for both teachers and students. Besides the
                 obvious advantage of being independent of the
                 programming language, the models help in the early
                 validation of concurrent software design, provide
                 students and teachers with a lingua franca that greatly
                 simplifies communication at the classroom and during
                 supervision, and help in the automatic generation of
                 tests for the practical assignments. This method has
                 been in use, with slight variations, for some 15 years,
                 surviving changes in the programming language and
                 course length. In this article, we describe the
                 components and structure of the current incarnation of
                 the course --- which uses Java as target language ---
                 and some tools used to support our method. We provide a
                 detailed description of the different outcomes that the
                 model-driven approach delivers (validation of the
                 initial design, automatic generation of tests, and
                 mechanical generation of code) from a teaching
                 perspective. A critical discussion on the perceived
                 advantages and risks of our approach follows, including
                 some proposals on how these risks can be minimized. We
                 include a statistical analysis to show that our method
                 has a positive impact in the student ability to
                 understand concurrency and to generate correct code.",
  acknowledgement = ack-nhfb,
  articleno =    "5",
  fjournal =     "ACM Transactions on Computing Education",
}

@Article{Carter:2013:SSA,
  author =       "Kyle Carter and Adam Foltzer and Joe Hendrix and Brian
                 Huffman and Aaron Tomb",
  title =        "{SAW}: the software analysis workbench",
  journal =      j-SIGADA-LETTERS,
  volume =       "33",
  number =       "3",
  pages =        "15--18",
  month =        dec,
  year =         "2013",
  CODEN =        "AALEE5",
  DOI =          "https://doi.org/10.1145/2658982.2527277",
  ISSN =         "1094-3641 (print), 1557-9476 (electronic)",
  ISSN-L =       "1094-3641",
  bibdate =      "Wed Sep 3 16:38:30 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/cryptography2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigada.bib",
  abstract =     "Galois has developed a suite of symbolic simulation
                 and formal analysis tools, collectively called the
                 Software Analysis Workbench (SAW). SAW provides
                 security analysts and engineers with the ability to
                 generate formal models from C and Java programs and
                 prove properties of those programs using several
                 automated verification tools. SAW is primarily used to
                 verify the correctness of cryptographic
                 implementations, and is able to import specifications
                 written in Cryptol, a language developed by Galois for
                 specifying cryptographic primitives. In this short
                 paper, we describe the main components of SAW. We then
                 given an overview of the cryptographic implementations
                 that have been verified.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGADA Ada Letters",
  journal-URL =  "http://portal.acm.org/citation.cfm?id=J32",
  remark =       "HILT '13 conference proceedings.",
}

@Article{Cavalcanti:2013:SCJ,
  author =       "Ana Cavalcanti and Andy Wellings and Jim Woodcock",
  title =        "The {Safety-Critical Java} memory model formalised",
  journal =      j-FORM-ASP-COMPUT,
  volume =       "25",
  number =       "1",
  pages =        "37--57",
  month =        jan,
  year =         "2013",
  CODEN =        "FACME5",
  DOI =          "https://doi.org/10.1007/s00165-012-0253-4",
  ISSN =         "0934-5043 (print), 1433-299X (electronic)",
  ISSN-L =       "0934-5043",
  bibdate =      "Tue Mar 17 20:58:44 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/formaspcomput.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://link.springer.com/article/10.1007/s00165-012-0253-4",
  acknowledgement = ack-nhfb,
  fjournal =     "Formal Aspects of Computing",
  journal-URL =  "http://link.springer.com/journal/165",
}

@Article{Choi:2013:GGT,
  author =       "Wontae Choi and George Necula and Koushik Sen",
  title =        "Guided {GUI} testing of {Android} apps with minimal
                 restart and approximate learning",
  journal =      j-SIGPLAN,
  volume =       "48",
  number =       "10",
  pages =        "623--640",
  month =        oct,
  year =         "2013",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2544173.2509552",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Dec 9 09:19:33 MST 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "OOPSLA '13 conference proceedings.",
  abstract =     "Smartphones and tablets with rich graphical user
                 interfaces (GUI) are becoming increasingly popular.
                 Hundreds of thousands of specialized applications,
                 called apps, are available for such mobile platforms.
                 Manual testing is the most popular technique for
                 testing graphical user interfaces of such apps. Manual
                 testing is often tedious and error-prone. In this
                 paper, we propose an automated technique, called
                 Swift-Hand, for generating sequences of test inputs for
                 Android apps. The technique uses machine learning to
                 learn a model of the app during testing, uses the
                 learned model to generate user inputs that visit
                 unexplored states of the app, and uses the execution of
                 the app on the generated inputs to refine the model. A
                 key feature of the testing algorithm is that it avoids
                 restarting the app, which is a significantly more
                 expensive operation than executing the app on a
                 sequence of inputs. An important insight behind our
                 testing algorithm is that we do not need to learn a
                 precise model of an app, which is often computationally
                 intensive, if our goal is to simply guide test
                 execution into unexplored parts of the state space. We
                 have implemented our testing algorithm in a publicly
                 available tool for Android apps written in Java. Our
                 experimental results show that we can achieve
                 significantly better coverage than traditional random
                 testing and L*-based testing in a given time budget.
                 Our algorithm also reaches peak coverage faster than
                 both random and L*-based testing.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{DElia:2013:BLP,
  author =       "Daniele Cono D'Elia and Camil Demetrescu",
  title =        "{Ball--Larus} path profiling across multiple loop
                 iterations",
  journal =      j-SIGPLAN,
  volume =       "48",
  number =       "10",
  pages =        "373--390",
  month =        oct,
  year =         "2013",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2544173.2509521",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Dec 9 09:19:33 MST 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "OOPSLA '13 conference proceedings.",
  abstract =     "Identifying the hottest paths in the control flow
                 graph of a routine can direct optimizations to portions
                 of the code where most resources are consumed. This
                 powerful methodology, called path profiling, was
                 introduced by Ball and Larus in the mid 90's [4] and
                 has received considerable attention in the last 15
                 years for its practical relevance. A shortcoming of the
                 Ball-Larus technique was the inability to profile
                 cyclic paths, making it difficult to mine execution
                 patterns that span multiple loop iterations. Previous
                 results, based on rather complex algorithms, have
                 attempted to circumvent this limitation at the price of
                 significant performance losses even for a small number
                 of iterations. In this paper, we present a new approach
                 to multi-iteration path profiling, based on data
                 structures built on top of the original Ball-Larus
                 numbering technique. Our approach allows the profiling
                 of all executed paths obtained as a concatenation of up
                 to k Ball-Larus acyclic paths, where k is a
                 user-defined parameter. We provide examples showing
                 that this method can reveal optimization opportunities
                 that acyclic-path profiling would miss. An extensive
                 experimental investigation on a large variety of Java
                 benchmarks on the Jikes RVM shows that our approach can
                 be even faster than Ball-Larus due to fewer operations
                 on smaller hash tables, producing compact
                 representations of cyclic paths even for large values
                 of k.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{DelRa:2013:BRJ,
  author =       "William {Del Ra III}",
  title =        "Book Review: {{\booktitle{Java application
                 architecture: modularity patterns with examples using
                 OSGi}} by Kirk Knoernschild}",
  journal =      j-SIGSOFT,
  volume =       "38",
  number =       "1",
  pages =        "55--55",
  month =        jan,
  year =         "2013",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/2413038.2413053",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:16:22 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Demange:2013:PBB,
  author =       "Delphine Demange and Vincent Laporte and Lei Zhao and
                 Suresh Jagannathan and David Pichardie and Jan Vitek",
  title =        "{Plan B}: a buffered memory model for {Java}",
  journal =      j-SIGPLAN,
  volume =       "48",
  number =       "1",
  pages =        "329--342",
  month =        jan,
  year =         "2013",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2480359.2429110",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Jul 1 17:15:03 MDT 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Recent advances in verification have made it possible
                 to envision trusted implementations of real-world
                 languages. Java with its type-safety and fully
                 specified semantics would appear to be an ideal
                 candidate; yet, the complexity of the translation steps
                 used in production virtual machines have made it a
                 challenging target for verifying compiler technology.
                 One of Java's key innovations, its memory model, poses
                 significant obstacles to such an endeavor. The Java
                 Memory Model is an ambitious attempt at specifying the
                 behavior of multithreaded programs in a portable,
                 hardware agnostic, way. While experts have an intuitive
                 grasp of the properties that the model should enjoy,
                 the specification is complex and not well-suited for
                 integration within a verifying compiler infrastructure.
                 Moreover, the specification is given in an axiomatic
                 style that is distant from the intuitive
                 reordering-based reasonings traditionally used to
                 justify or rule out behaviors, and ill suited to the
                 kind of operational reasoning one would expect to
                 employ in a compiler. This paper takes a step back, and
                 introduces a Buffered Memory Model (BMM) for Java. We
                 choose a pragmatic point in the design space
                 sacrificing generality in favor of a model that is
                 fully characterized in terms of the reorderings it
                 allows, amenable to formal reasoning, and which can be
                 efficiently applied to a specific hardware family,
                 namely x86 multiprocessors. Although the BMM restricts
                 the reorderings compilers are allowed to perform, it
                 serves as the key enabling device to achieving a
                 verification pathway from bytecode to machine
                 instructions. Despite its restrictions, we show that it
                 is backwards compatible with the Java Memory Model and
                 that it does not cripple performance on TSO
                 architectures.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "POPL '13 conference proceedings.",
}

@Article{Dey:2013:STA,
  author =       "Akon Dey and Alan Fekete and Uwe R{\"o}hm",
  title =        "Scalable transactions across heterogeneous {NoSQL}
                 key-value data stores",
  journal =      j-PROC-VLDB-ENDOWMENT,
  volume =       "6",
  number =       "12",
  pages =        "1434--1439",
  month =        aug,
  year =         "2013",
  CODEN =        "????",
  ISSN =         "2150-8097",
  bibdate =      "Fri Dec 13 05:57:00 MST 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/vldbe.bib",
  abstract =     "Many cloud systems provide data stores with limited
                 features, especially they may not provide transactions,
                 or else restrict transactions to a single item. We
                 propose a approach that gives multi-item transactions
                 across heterogeneous data stores, using only a minimal
                 set of features from each store such as single item
                 consistency, conditional update, and the ability to
                 include extra metadata within a value. We offer a
                 client-coordinated transaction protocol that does not
                 need a central coordinating infrastructure. A prototype
                 implementation has been built as a Java library and
                 measured with an extension of YCSB benchmark to
                 exercise multi-item transactions.",
  acknowledgement = ack-nhfb,
  fjournal =     "Proceedings of the VLDB Endowment",
}

@Article{Dias:2013:SIP,
  author =       "Ricardo J. Dias and Tiago M. Vale and Jo{\~a}o M.
                 Louren{\c{c}}o",
  title =        "Special Issue Papers: Efficient support for in-place
                 metadata in {Java} software transactional memory",
  journal =      j-CCPE,
  volume =       "25",
  number =       "17",
  pages =        "2394--2411",
  day =          "10",
  month =        dec,
  year =         "2013",
  CODEN =        "CCPEBO",
  DOI =          "https://doi.org/10.1002/cpe.3098",
  ISSN =         "1532-0626 (print), 1532-0634 (electronic)",
  ISSN-L =       "1532-0626",
  bibdate =      "Tue Dec 3 10:37:48 MST 2013",
  bibsource =    "http://www.interscience.wiley.com/jpages/1532-0626;
                 https://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Concurrency and Computation: Practice and Experience",
  journal-URL =  "http://www.interscience.wiley.com/jpages/1532-0626",
  onlinedate =   "19 Jul 2013",
}

@Article{Diaz:2013:LEU,
  author =       "Oscar D{\'\i}az and Crist{\'o}bal Arellano and Maider
                 Azanza",
  title =        "A language for end-user {Web} augmentation: Caring for
                 producers and consumers alike",
  journal =      j-TWEB,
  volume =       "7",
  number =       "2",
  pages =        "9:1--9:??",
  month =        may,
  year =         "2013",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/2460383.2460388",
  ISSN =         "1559-1131 (print), 1559-114X (electronic)",
  ISSN-L =       "1559-1131",
  bibdate =      "Thu Mar 13 08:28:18 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/tweb.bib",
  abstract =     "Web augmentation is to the Web what augmented reality
                 is to the physical world: layering relevant
                 content/layout/navigation over the existing Web to
                 customize the user experience. This is achieved through
                 JavaScript (JS) using browser weavers (e.g.,
                 Greasemonkey). To date, over 43 million of downloads of
                 Greasemonkey scripts ground the vitality of this
                 movement. However, Web augmentation is hindered by
                 being programming intensive and prone to malware. This
                 prevents end-users from participating as both producers
                 and consumers of scripts: producers need to know JS,
                 consumers need to trust JS. This article aims at
                 promoting end-user participation in both roles. The
                 vision is for end-users to prosume (the act of
                 simultaneously caring for producing and consuming)
                 scripts as easily as they currently prosume their
                 pictures or videos. Encouraging production requires
                 more ``natural'' and abstract constructs. Promoting
                 consumption calls for augmentation scripts to be easier
                 to understand, share, and trust upon. To this end, we
                 explore the use of Domain-Specific Languages (DSLs) by
                 introducing Sticklet. Sticklet is an internal DSL on
                 JS, where JS generality is reduced for the sake of
                 learnability and reliability. Specifically, Web
                 augmentation is conceived as fixing in existing web
                 sites (i.e., the wall ) HTML fragments extracted from
                 either other sites or Web services (i.e., the stickers
                 ). Sticklet targets hobby programmers as producers, and
                 computer literates as consumers. From a producer
                 perspective, benefits are threefold. As a restricted
                 grammar on top of JS, Sticklet expressions are domain
                 oriented and more declarative than their JS
                 counterparts, hence speeding up development. As
                 syntactically correct JS expressions, Sticklet scripts
                 can be installed as traditional scripts and hence,
                 programmers can continue using existing JS tools. As
                 declarative expressions, they are easier to maintain,
                 and amenable for optimization. From a consumer
                 perspective, domain specificity brings
                 understandability (due to declarativeness), reliability
                 (due to built-in security), and ``consumability''
                 (i.e., installation/enactment/sharing of Sticklet
                 expressions are tuned to the shortage of time and
                 skills of the target audience). Preliminary evaluations
                 indicate that 77\% of the subjects were able to develop
                 new Sticklet scripts in less than thirty minutes while
                 84\% were able to consume these scripts in less than
                 ten minutes. Sticklet is available to download as a
                 Mozilla add-on.",
  acknowledgement = ack-nhfb,
  articleno =    "9",
  fjournal =     "ACM Transactions on the Web (TWEB)",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J1062",
}

@Article{Efftinge:2013:XID,
  author =       "Sven Efftinge and Moritz Eysholdt and Jan K{\"o}hnlein
                 and Sebastian Zarnekow and Robert von Massow and
                 Wilhelm Hasselbring and Michael Hanus",
  title =        "{Xbase}: implementing domain-specific languages for
                 {Java}",
  journal =      j-SIGPLAN,
  volume =       "48",
  number =       "3",
  pages =        "112--121",
  month =        mar,
  year =         "2013",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2480361.2371419",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Jul 1 17:15:18 MDT 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Xtext is an open-source framework for implementing
                 external, textual domain-specific languages (DSLs). So
                 far, most DSLs implemented with Xtext and similar tools
                 focus on structural aspects such as service
                 specifications and entities. Because behavioral aspects
                 are significantly more complicated to implement, they
                 are often delegated to general-purpose programming
                 languages. This approach introduces complex integration
                 patterns and the DSL's high level of abstraction is
                 compromised. We present Xbase as part of Xtext, an
                 expression language that can be reused via language
                 inheritance in any DSL implementation based on Xtext.
                 Xbase expressions provide both control structures and
                 program expressions in a uniform way. Xbase is
                 statically typed and tightly integrated with the Java
                 type system. Languages extending Xbase inherit the
                 syntax of a Java-like expression language as well as
                 language infrastructure components, including a parser,
                 an unparser, a linker, a compiler and an interpreter.
                 Furthermore, the framework provides integration into
                 the Eclipse IDE including debug and refactoring
                 support. The application of Xbase is presented by means
                 of a domain model language which serves as a tutorial
                 example and by the implementation of the programming
                 language Xtend. Xtend is a functional and
                 object-oriented general purpose language for the Java
                 Virtual Machine (JVM). It is built on top of Xbase
                 which is the reusable expression language that is the
                 foundation of Xtend.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "GPCE '12 conference proceedings.",
}

@Article{Eugster:2013:SUP,
  author =       "Patrick Eugster",
  title =        "Safe uniform proxies for {Java}",
  journal =      j-SCI-COMPUT-PROGRAM,
  volume =       "78",
  number =       "9",
  pages =        "1490--1520",
  day =          "1",
  month =        sep,
  year =         "2013",
  CODEN =        "SCPGD4",
  ISSN =         "0167-6423 (print), 1872-7964 (electronic)",
  ISSN-L =       "0167-6423",
  bibdate =      "Tue Sep 3 06:34:36 MDT 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/scicomputprogram.bib;
                 http://www.sciencedirect.com/science/journal/01676423",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0167642312002043",
  acknowledgement = ack-nhfb,
  fjournal =     "Science of Computer Programming",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01676423",
}

@Book{Evans:2013:WGJ,
  author =       "Benjamin J. Evans and Martijn Verburg",
  title =        "The well-grounded {Java} developer: vital techniques
                 of {Java 7} and polyglot programming",
  publisher =    pub-MANNING,
  address =      pub-MANNING:adr,
  pages =        "xxx + 462",
  year =         "2013",
  ISBN =         "1-61729-006-8",
  ISBN-13 =      "978-1-61729-006-0",
  LCCN =         "QA76.73.J38 E93 2013",
  bibdate =      "Fri Dec 28 05:47:55 MST 2012",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  note =         "Foreword by Heinz Kabutz.",
  URL =          "http://www.loc.gov/catdir/enhancements/fy1304/2012288194-b.html;
                 http://www.loc.gov/catdir/enhancements/fy1304/2012288194-d.html",
  acknowledgement = ack-nhfb,
  subject =      "Java virtual machine; Java (Computer program
                 language); Functional programming (Computer science);
                 Application software; Development",
  tableofcontents = "Developing with Java 7 \\
                 Vital techniques \\
                 Polyglot programming on the JVM \\
                 Crafting the polyglot project",
}

@Article{Feldthaus:2013:SAR,
  author =       "Asger Feldthaus and Anders M{\o}ller",
  title =        "Semi-automatic rename refactoring for {JavaScript}",
  journal =      j-SIGPLAN,
  volume =       "48",
  number =       "10",
  pages =        "323--338",
  month =        oct,
  year =         "2013",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2544173.2509520",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Dec 9 09:19:33 MST 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "OOPSLA '13 conference proceedings.",
  abstract =     "Modern IDEs support automated refactoring for many
                 programming languages, but support for JavaScript is
                 still primitive. To perform renaming, which is one of
                 the fundamental refactorings, there is often no
                 practical alternative to simple syntactic
                 search-and-replace. Although more sophisticated
                 alternatives have been developed, they are limited by
                 whole-program assumptions and poor scalability. We
                 propose a technique for semi-automatic refactoring for
                 JavaScript, with a focus on renaming. Unlike
                 traditional refactoring algorithms, semi-automatic
                 refactoring works by a combination of static analysis
                 and interaction with the programmer. With this
                 pragmatic approach, we can provide scalable and
                 effective refactoring support for real-world code,
                 including libraries and incomplete applications.
                 Through a series of experiments that estimate how much
                 manual effort our technique demands from the
                 programmer, we show that our approach is a useful
                 improvement compared to search-and-replace tools.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Ferrara:2013:GSA,
  author =       "P. Ferrara",
  title =        "A generic static analyzer for multithreaded {Java}
                 programs",
  journal =      j-SPE,
  volume =       "43",
  number =       "6",
  pages =        "663--684",
  month =        jun,
  year =         "2013",
  CODEN =        "SPEXBL",
  DOI =          "https://doi.org/10.1002/spe.2126",
  ISSN =         "0038-0644 (print), 1097-024X (electronic)",
  ISSN-L =       "0038-0644",
  bibdate =      "Tue Dec 3 10:30:05 MST 2013",
  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/spe.bib;
                 http://www3.interscience.wiley.com/journalfinder.html",
  acknowledgement = ack-nhfb,
  fjournal =     "Software --- Practice and Experience",
  journal-URL =  "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)1097-024X",
  onlinedate =   "9 May 2012",
}

@Article{Flanagan:2013:PES,
  author =       "Cormac Flanagan and K. Rustan M. Leino and Mark
                 Lillibridge and Greg Nelson and James B. Saxe and
                 Raymie Stata",
  title =        "{PLDI 2002}: Extended static checking for {Java}",
  journal =      j-SIGPLAN,
  volume =       "48",
  number =       "4S",
  pages =        "22--33",
  month =        apr,
  year =         "2013",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2502508.2502520",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Jul 15 15:53:11 MDT 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Software development and maintenance are costly
                 endeavors. The cost can be reduced if more software
                 defects are detected earlier in the development cycle.
                 This paper introduces the Extended Static Checker for
                 Java (ESC/Java), an experimental compile-time program
                 checker that finds common programming errors. The
                 checker is powered by verification-condition generation
                 and automatic theorem-proving techniques. It provides
                 programmers with a simple annotation language with
                 which programmer design decisions can be expressed
                 formally. ESC/Java examines the annotated software and
                 warns of inconsistencies between the design decisions
                 recorded in the annotations and the actual code, and
                 also warns of potential runtime errors in the code.
                 This paper gives an overview of the checker
                 architecture and annotation language and describes our
                 experience applying the checker to tens of thousands of
                 lines of Java programs.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Fournet:2013:FAC,
  author =       "Cedric Fournet and Nikhil Swamy and Juan Chen and
                 Pierre-Evariste Dagand and Pierre-Yves Strub and
                 Benjamin Livshits",
  title =        "Fully abstract compilation to {JavaScript}",
  journal =      j-SIGPLAN,
  volume =       "48",
  number =       "1",
  pages =        "371--384",
  month =        jan,
  year =         "2013",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2480359.2429114",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Jul 1 17:15:03 MDT 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Many tools allow programmers to develop applications
                 in high-level languages and deploy them in web browsers
                 via compilation to JavaScript. While practical and
                 widely used, these compilers are ad hoc: no guarantee
                 is provided on their correctness for whole programs,
                 nor their security for programs executed within
                 arbitrary JavaScript contexts. This paper presents a
                 compiler with such guarantees. We compile an ML-like
                 language with higher-order functions and references to
                 JavaScript, while preserving all source program
                 properties. Relying on type-based invariants and
                 applicative bisimilarity, we show full abstraction: two
                 programs are equivalent in all source contexts if and
                 only if their wrapped translations are equivalent in
                 all JavaScript contexts. We evaluate our compiler on
                 sample programs, including a series of secure
                 libraries.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "POPL '13 conference proceedings.",
}

@Article{Gadyatskaya:2013:LTC,
  author =       "Olga Gadyatskaya and Fabio Massacci and Quang-Huy
                 Nguyen and Boutheina Chetali",
  title =        "Load time code validation for mobile phone {Java}
                 Cards",
  journal =      j-J-INFO-SEC-APPL,
  volume =       "18",
  number =       "2--3",
  pages =        "108--129",
  month =        sep,
  year =         "2013",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1016/j.jisa.2013.07.004",
  ISSN =         "2214-2126",
  ISSN-L =       "2214-2126",
  bibdate =      "Sun May 8 11:59:03 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/jinfosecappl.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S2214212613000318",
  acknowledgement = ack-nhfb,
  ajournal =     "J. Info. Sec. Appl.",
  fjournal =     "Journal of Information Security and Applications
                 (JISA)",
  journal-URL =  "http://www.sciencedirect.com/science/journal/22142126",
}

@Article{Gerakios:2013:FIS,
  author =       "Prodromos Gerakios and Aggelos Biboudis and Yannis
                 Smaragdakis",
  title =        "Forsaking inheritance: supercharged delegation in
                 {DelphJ}",
  journal =      j-SIGPLAN,
  volume =       "48",
  number =       "10",
  pages =        "233--252",
  month =        oct,
  year =         "2013",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2544173.2509535",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Dec 9 09:19:33 MST 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "OOPSLA '13 conference proceedings.",
  abstract =     "We propose DelphJ: a Java-based OO language that
                 eschews inheritance completely, in favor of a
                 combination of class morphing and (deep) delegation.
                 Compared to past delegation approaches, the novel
                 aspect of our design is the ability to emulate the best
                 aspects of inheritance while retaining maximum
                 flexibility: using morphing, a class can select any of
                 the methods of its delegatee and export them (if
                 desired) or transform them (e.g., to add extra
                 arguments or modify type signatures), yet without
                 needing to name these methods explicitly and handle
                 them one-by-one. Compared to past work on morphing, our
                 approach adopts and adapts advanced delegation
                 mechanisms, in order to add late binding capabilities
                 and, thus, provide a full substitute of inheritance.
                 Additionally, we explore complex semantic issues in the
                 interaction of delegation with late binding. We present
                 our language design both informally, with numerous
                 examples, and formally in a core calculus.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Gonzalez:2013:HBP,
  author =       "Apolinar Gonzalez and Walter Mata and Alfons Crespo
                 and Miguel Masmano and Jos{\'e} F{\'e}lix and Alvaro
                 Aburto",
  title =        "A hypervisor based platform to support real-time
                 safety critical embedded {Java} applications",
  journal =      j-INT-J-COMPUT-SYST-SCI-ENG,
  volume =       "28",
  number =       "3",
  pages =        "??--??",
  month =        "????",
  year =         "2013",
  CODEN =        "CSSEEI",
  ISSN =         "0267-6192",
  ISSN-L =       "0267-6192",
  bibdate =      "Tue Dec 3 12:04:33 MST 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/computsystscieng.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "International Journal of Computer Systems Science and
                 Engineering",
}

@Book{Gosling:2013:JLS,
  author =       "James Gosling and Bill Joy and Guy L. {Steele Jr.} and
                 Gilad Bracha and Alex Buckley",
  title =        "The {Java} Language Specification",
  publisher =    pub-AW,
  address =      pub-AW:adr,
  edition =      "{Java SE 7}",
  pages =        "xxvii + 644",
  year =         "2013",
  ISBN =         "0-13-326022-4 (paperback)",
  ISBN-13 =      "978-0-13-326022-9 (paperback)",
  LCCN =         "QA76.73.J38 G68 2013",
  bibdate =      "Mon Jan 28 14:57:19 MST 2013",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/mathcw.bib",
  acknowledgement = ack-nhfb,
  remark =       "Previous ed.: Boston, Mass.; London: Addison-Wesley,
                 2005.",
  subject =      "Java (Computer program language)",
}

@Article{Gvero:2013:BRC,
  author =       "Igor Gvero",
  title =        "Book Review: {{\booktitle{Core Java volume I:
                 fundamentals}}, 9th edition by Cay S. Horstmann and
                 Gary Cornell}",
  journal =      j-SIGSOFT,
  volume =       "38",
  number =       "3",
  pages =        "33--33",
  month =        may,
  year =         "2013",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/2464526.2464552",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:16:25 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Haddad:2013:SIP,
  author =       "Ghaith Haddad and Gary T. Leavens",
  title =        "Special Issue Papers: Specifying subtypes in {Safety
                 Critical Java} programs",
  journal =      j-CCPE,
  volume =       "25",
  number =       "16",
  pages =        "2290--2306",
  month =        nov,
  year =         "2013",
  CODEN =        "CCPEBO",
  DOI =          "https://doi.org/10.1002/cpe.2930",
  ISSN =         "1532-0626 (print), 1532-0634 (electronic)",
  ISSN-L =       "1532-0626",
  bibdate =      "Tue Dec 3 10:37:44 MST 2013",
  bibsource =    "http://www.interscience.wiley.com/jpages/1532-0626;
                 https://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Concurrency and Computation: Practice and Experience",
  journal-URL =  "http://www.interscience.wiley.com/jpages/1532-0626",
  onlinedate =   "4 Oct 2012",
}

@Article{Haubl:2013:CST,
  author =       "Christian H{\"a}ubl and Christian Wimmer and Hanspeter
                 M{\"o}ssenb{\"o}ck",
  title =        "Context-sensitive trace inlining for {Java}",
  journal =      j-COMP-LANGS-SYS-STRUCT,
  volume =       "39",
  number =       "4",
  pages =        "123--141",
  month =        dec,
  year =         "2013",
  CODEN =        "????",
  ISSN =         "1477-8424 (print), 1873-6866 (electronic)",
  ISSN-L =       "1477-8424",
  bibdate =      "Thu Mar 6 07:28:19 MST 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/complngs.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S1477842413000146",
  acknowledgement = ack-nhfb,
  fjournal =     "Computer Languages, Systems and Structures",
  journal-URL =  "http://www.sciencedirect.com/science/journal/14778424/",
}

@Article{Hauswirth:2013:TJP,
  author =       "Matthias Hauswirth and Andrea Adamoli",
  title =        "Teaching {Java} programming with the {Informa} clicker
                 system",
  journal =      j-SCI-COMPUT-PROGRAM,
  volume =       "78",
  number =       "5",
  pages =        "499--520",
  day =          "1",
  month =        may,
  year =         "2013",
  CODEN =        "SCPGD4",
  ISSN =         "0167-6423 (print), 1872-7964 (electronic)",
  ISSN-L =       "0167-6423",
  bibdate =      "Wed Mar 27 07:52:16 MDT 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/scicomputprogram.bib;
                 http://www.sciencedirect.com/science/journal/01676423",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0167642311001468",
  acknowledgement = ack-nhfb,
  fjournal =     "Science of Computer Programming",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01676423",
}

@Article{Herczeg:2013:TFF,
  author =       "Zolt{\'a}n Herczeg and G{\'a}bor L{\'o}ki and
                 Tam{\'a}s Szirbucz and {\'A}kos Kiss",
  title =        "Validating {JavaScript} Guidelines across Multiple
                 {Web} Browsers",
  journal =      j-NORDIC-J-COMPUT,
  volume =       "15",
  number =       "1",
  pages =        "18--31",
  month =        "Summer",
  year =         "2013",
  CODEN =        "NJCOFR",
  ISSN =         "1236-6064",
  bibdate =      "Sun May 5 11:09:02 MDT 2013",
  bibsource =    "http://www.cs.helsinki.fi/njc/njc15.html;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Nordic Journal of Computing",
}

@Article{Herhut:2013:RTP,
  author =       "Stephan Herhut and Richard L. Hudson and Tatiana
                 Shpeisman and Jaswanth Sreeram",
  title =        "{River Trail}: a path to parallelism in {JavaScript}",
  journal =      j-SIGPLAN,
  volume =       "48",
  number =       "10",
  pages =        "729--744",
  month =        oct,
  year =         "2013",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2544173.2509516",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Dec 9 09:19:33 MST 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "OOPSLA '13 conference proceedings.",
  abstract =     "JavaScript is the most popular language on the web and
                 is a crucial component of HTML5 applications and
                 services that run on consumer platforms ranging from
                 desktops to phones. However, despite ample amount of
                 hardware parallelism available to web applications on
                 such platforms, JavaScript web applications remain
                 predominantly sequential. Common parallel programming
                 solutions accepted by other programming languages
                 failed to transfer themselves to JavaScript due to
                 differences in programming models, the additional
                 requirements of the web and different developer
                 expectations. In this paper we present River Trail ---
                 a parallel programming model and API for JavaScript
                 that provides safe, portable, programmer-friendly,
                 deterministic parallelism to JavaScript applications.
                 River Trail allows web applications to effectively
                 utilize multiple cores, vector instructions, and GPUs
                 on client platforms while allowing the web developer to
                 remain within the environment of JavaScript. We
                 describe the implementation of the River Trail compiler
                 and runtime and present experimental results that show
                 the impact of River Trail on performance and
                 scalability for a variety of realistic HTML5
                 applications. Our experiments show that River Trail has
                 a dramatic positive impact on overall performance and
                 responsiveness of computationally intense JavaScript
                 based applications achieving up to 33.6 times speedup
                 for kernels and up to 11.8 times speedup for realistic
                 web applications compared to sequential JavaScript.
                 Moreover, River Trail enables new interactive web
                 usages that are simply not even possible with standard
                 sequential JavaScript.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Heumann:2013:TEM,
  author =       "Stephen T. Heumann and Vikram S. Adve and Shengjie
                 Wang",
  title =        "The tasks with effects model for safe concurrency",
  journal =      j-SIGPLAN,
  volume =       "48",
  number =       "8",
  pages =        "239--250",
  month =        aug,
  year =         "2013",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2517327.2442540",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Aug 26 13:48:51 MDT 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "PPoPP '13 Conference proceedings.",
  abstract =     "Today's widely-used concurrent programming models
                 either provide weak safety guarantees, making it easy
                 to write code with subtle errors, or are limited in the
                 class of programs that they can express. We propose a
                 new concurrent programming model based on tasks with
                 effects that offers strong safety guarantees while
                 still providing the flexibility needed to support the
                 many ways that concurrency is used in complex
                 applications. The core unit of work in our model is a
                 dynamically-created task. The model's key feature is
                 that each task has programmer-specified effects, and a
                 run-time scheduler is used to ensure that two tasks are
                 run concurrently only if they have non-interfering
                 effects. Through the combination of statically
                 verifying the declared effects of tasks and using an
                 effect-aware run-time scheduler, our model is able to
                 guarantee strong safety properties, including data race
                 freedom and atomicity. It is also possible to use our
                 model to write programs and computations that can be
                 statically proven to behave deterministically. We
                 describe the tasks with effects programming model and
                 provide a formal dynamic semantics for it. We also
                 describe our implementation of this model in an
                 extended version of Java and evaluate its use in
                 several programs exhibiting various patterns of
                 concurrency.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Book{Hinojosa:2013:TS,
  author =       "Daniel Hinojosa",
  title =        "Testing in {Scala}",
  publisher =    pub-ORA-MEDIA,
  address =      pub-ORA-MEDIA:adr,
  pages =        "xiv + 148",
  year =         "2013",
  ISBN =         "1-4493-1511-9, 1-4493-6034-3 (e-book), 1-4493-6033-5
                 (e-book)",
  ISBN-13 =      "978-1-4493-1511-5, 978-1-4493-6034-4 (e-book),
                 978-1-4493-6033-7 (e-book)",
  LCCN =         "QA76.7 .H555 2013",
  bibdate =      "Thu Dec 4 08:38:57 MST 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/ora.bib;
                 z3950.loc.gov:7090/Voyager",
  URL =          "http://proquest.tech.safaribooksonline.de/9781449360313;
                 http://www.loc.gov/catdir/enhancements/fy1310/2012554271-b.html;
                 http://www.loc.gov/catdir/enhancements/fy1310/2012554271-d.html",
  acknowledgement = ack-nhfb,
  subject =      "Programming languages (Electronic computers);
                 Multiparadigm programming (Computer science);
                 Object-oriented programming (Computer science);
                 Functional programming (Computer science); Java virtual
                 machine; Functional programming languages;
                 Object-oriented programming languages",
}

@Article{Hoppe:2013:DDB,
  author =       "Michael Hoppe and Stefan Hanenberg",
  title =        "Do developers benefit from generic types?: an
                 empirical comparison of generic and raw types in
                 {Java}",
  journal =      j-SIGPLAN,
  volume =       "48",
  number =       "10",
  pages =        "457--474",
  month =        oct,
  year =         "2013",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2544173.2509528",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Dec 9 09:19:33 MST 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "OOPSLA '13 conference proceedings.",
  abstract =     "Type systems that permit developers to express
                 themselves more precisely are one of the primary topics
                 in programming language research, as well as in
                 industrial software development. While it seems
                 plausible that an expressive static type system
                 increases developer productivity, there is little
                 empirical evidence for or against this hypothesis.
                 Generic types in Java are an example: as an extension
                 of Java's original type system, some claim that Java
                 1.5 improves the type system's ``expressiveness.'' Even
                 if this claim is true, there exists little empirical
                 evidence that claimed expressiveness leads to a
                 measurable increase in developer productivity. This
                 paper introduces an experiment where generic types (in
                 comparison to raw types) have been evaluated in three
                 different directions: (1) the documentation impact on
                 undocumented APIs, (2) the time required for fixing
                 type errors, and (3) the extensibility of a generic
                 type hierarchy. The results of the experiment suggest
                 that generic types improve documentation and reduce
                 extensibility --- without revealing a difference in the
                 time required for fixing type errors.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Book{Horstmann:2013:CJF,
  author =       "Cay S. Horstmann and Gary Cornell",
  title =        "Core {Java}: Fundamentals",
  volume =       "1",
  publisher =    pub-PH,
  address =      pub-PH:adr,
  edition =      "Ninth",
  pages =        "xxvi + 974",
  year =         "2013",
  ISBN =         "0-13-708189-8 (paperback)",
  ISBN-13 =      "978-0-13-708189-9 (paperback)",
  LCCN =         "QA76.73.J38 H6753 2013",
  bibdate =      "Mon Jan 28 14:54:07 MST 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 library.ox.ac.uk:210/ADVANCE",
  acknowledgement = ack-nhfb,
  subject =      "Java (Computer program language)",
  tableofcontents = "Vol. 1. Fundamentals \\
                 vol. 2. Advance features",
  xxaddress =    "Redwood Shores, CA, USA",
}

@Article{Huang:2013:ECS,
  author =       "Jipeng Huang and Michael D. Bond",
  title =        "Efficient context sensitivity for dynamic analyses via
                 calling context uptrees and customized memory
                 management",
  journal =      j-SIGPLAN,
  volume =       "48",
  number =       "10",
  pages =        "53--72",
  month =        oct,
  year =         "2013",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2544173.2509510",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Dec 9 09:19:33 MST 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  note =         "OOPSLA '13 conference proceedings.",
  abstract =     "State-of-the-art dynamic bug detectors such as data
                 race and memory leak detectors report program locations
                 that are likely causes of bugs. However, programmers
                 need more than static program locations to understand
                 the behavior of increasingly complex and concurrent
                 software. Dynamic calling context provides additional
                 information, but it is expensive to record calling
                 context frequently, e.g., at every read and write.
                 Context-sensitive dynamic analyses can build and
                 maintain a calling context tree (CCT) to track calling
                 context--but in order to reuse existing nodes,
                 CCT-based approaches require an expensive lookup. This
                 paper introduces a new approach for context sensitivity
                 that avoids this expensive lookup. The approach uses a
                 new data structure called the calling context uptree
                 (CCU) that adds low overhead by avoiding the lookup and
                 instead allocating a new node for each context. A key
                 contribution is that the approach can mitigate the
                 costs of allocating many nodes by extending tracing
                 garbage collection (GC): GC collects unused CCU nodes
                 naturally and efficiently, and we extend GC to merge
                 duplicate nodes lazily. We implement our CCU-based
                 approach in a high-performance Java virtual machine and
                 integrate it with a staleness-based memory leak
                 detector and happens-before data race detector, so they
                 can report context-sensitive program locations that
                 cause bugs. We show that the CCU-based approach, in
                 concert with an extended GC, provides a compelling
                 alternative to CCT-based approaches for adding context
                 sensitivity to dynamic analyses.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Jaffer:2013:EAR,
  author =       "Aubrey Jaffer",
  title =        "Easy Accurate Reading and Writing of Floating-Point
                 Numbers",
  journal =      "arXiv.org",
  volume =       "??",
  number =       "??",
  pages =        "1--7",
  day =          "28",
  month =        oct,
  year =         "2013",
  CODEN =        "????",
  ISSN =         "????",
  ISSN-L =       "????",
  MRclass =      "65G04",
  bibdate =      "Wed Sep 30 12:43:49 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/fparith.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://arxiv.org/abs/1310.8121",
  abstract =     "Presented here are algorithms for converting between
                 (decimal) scientific-notation and (binary) IEEE-754
                 double-precision floating-point numbers. By employing a
                 rounding integer quotient operation these algorithms
                 are much simpler than those previously published. The
                 values are stable under repeated conversions between
                 the formats. Unlike Java-1.6, the scientific
                 representations generated use only the minimum number
                 of mantissa digits needed to convert back to the
                 original binary values. Implemented in Java these
                 algorithms execute as fast or faster than Java's native
                 conversions over nearly all of the IEEE-754
                 double-precision range.",
  acknowledgement = ack-nhfb,
  keywords =     "base conversion; input-output conversion; radix
                 conversion; round-trip base conversion",
  subject =      "Numerical Analysis (cs.NA)",
}

@Article{Jantz:2013:ESM,
  author =       "Michael R. Jantz and Prasad A. Kulkarni",
  title =        "Exploring single and multilevel {JIT} compilation
                 policy for modern machines 1",
  journal =      j-TACO,
  volume =       "10",
  number =       "4",
  pages =        "22:1--22:??",
  month =        dec,
  year =         "2013",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/2541228.2541229",
  ISSN =         "1544-3566 (print), 1544-3973 (electronic)",
  ISSN-L =       "1544-3566",
  bibdate =      "Mon Dec 23 10:31:41 MST 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/csharp.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/taco.bib",
  abstract =     "Dynamic or Just-in-Time (JIT) compilation is essential
                 to achieve high-performance emulation for programs
                 written in managed languages, such as Java and C\#. It
                 has been observed that a conservative JIT compilation
                 policy is most effective to obtain good runtime
                 performance without impeding application progress on
                 single-core machines. At the same time, it is often
                 suggested that a more aggressive dynamic compilation
                 strategy may perform best on modern machines that
                 provide abundant computing resources, especially with
                 virtual machines (VMs) that are also capable of
                 spawning multiple concurrent compiler threads. However,
                 comprehensive research on the best JIT compilation
                 policy for such modern processors and VMs is currently
                 lacking. The goal of this work is to explore the
                 properties of single-tier and multitier JIT compilation
                 policies that can enable existing and future VMs to
                 realize the best program performance on modern
                 machines. In this work, we design novel experiments and
                 implement new VM configurations to effectively control
                 the compiler aggressiveness and optimization levels (
                 if and when methods are compiled) in the
                 industry-standard Oracle HotSpot Java VM to achieve
                 this goal. We find that the best JIT compilation policy
                 is determined by the nature of the application and the
                 speed and effectiveness of the dynamic compilers. We
                 extend earlier results showing the suitability of
                 conservative JIT compilation on single-core machines
                 for VMs with multiple concurrent compiler threads. We
                 show that employing the free compilation resources
                 (compiler threads and hardware cores) to aggressively
                 compile more program methods quickly reaches a point of
                 diminishing returns. At the same time, we also find
                 that using the free resources to reduce compiler queue
                 backup (compile selected hot methods early )
                 significantly benefits program performance, especially
                 for slower (highly optimizing) JIT compilers. For such
                 compilers, we observe that accurately prioritizing JIT
                 method compiles is crucial to realize the most
                 performance benefit with the smallest hardware budget.
                 Finally, we show that a tiered compilation policy,
                 although complex to implement, greatly alleviates the
                 impact of more and early JIT compilation of programs on
                 modern machines.",
  acknowledgement = ack-nhfb,
  articleno =    "22",
  fjournal =     "ACM Transactions on Architecture and Code Optimization
                 (TACO)",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J924",
}

@Article{Kaufmann:2013:SCO,
  author =       "Marco Kaufmann and Rainer G. Spallek",
  title =        "Superblock compilation and other optimization
                 techniques for a {Java}-based {DBT} machine emulator",
  journal =      j-SIGPLAN,
  volume =       "48",
  number =       "7",
  pages =        "33--40",
  month =        jul,
  year =         "2013",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2517326.2451521",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Aug 26 13:55:17 MDT 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  note =         "VEE '13 Conference proceedings.",
  abstract =     "Superblock compilation techniques such as control flow
                 graph (CFG) or trace compilation have become a widely
                 adopted approach to increase the performance of
                 dynamically compiling virtual machines even further.
                 While this was shown to be successful for many
                 conventional virtual machines, it did not result in a
                 higher performance for Java-based DBT machine emulators
                 so far. These emulators dynamically translate
                 application binaries of a target machine into Java
                 bytecode, which is then eventually compiled into the
                 native code of the emulating host by the Java Virtual
                 Machine (JVM). Successful superblock compilation
                 techniques for this class of emulators must consider
                 the special requirements that result from the two-stage
                 translation as well as the characteristics of the JVM,
                 such as the inability of most Java JIT compilers to
                 handle large bytecode methods efficiently. In this
                 paper, we present a superblock compilation approach for
                 a Java-based DBT machine emulator that generates a
                 performance increase of up to 90 percent and of 32
                 percent on average. The key idea of our design is to
                 provide a large scope over the control flow of target
                 applications across basic block boundaries for the JVM,
                 while still keeping small bytecode methods for the
                 execution units. In addition, we also present two
                 further optimizations --- interpreter context
                 elimination and program counter elimination --- which
                 increase the emulation performance by 16 percent again.
                 In total, the optimization techniques discussed in this
                 paper provide an average performance gain of 48 percent
                 for the surveyed emulator.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Kerschbaumer:2013:IFT,
  author =       "Christoph Kerschbaumer and Eric Hennigan and Per
                 Larsen and Stefan Brunthaler and Michael Franz",
  title =        "Information flow tracking meets just-in-time
                 compilation",
  journal =      j-TACO,
  volume =       "10",
  number =       "4",
  pages =        "38:1--38:??",
  month =        dec,
  year =         "2013",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/2541228.2555295",
  ISSN =         "1544-3566 (print), 1544-3973 (electronic)",
  ISSN-L =       "1544-3566",
  bibdate =      "Thu Jan 9 10:42:35 MST 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/taco.bib",
  abstract =     "Web applications are vulnerable to cross-site
                 scripting attacks that enable data thefts. Information
                 flow tracking in web browsers can prevent communication
                 of sensitive data to unintended recipients and thereby
                 stop such data thefts. Unfortunately, existing
                 solutions have focused on incorporating information
                 flow into browsers' JavaScript interpreters, rather
                 than just-in-time compilers, rendering the resulting
                 performance noncompetitive. Few users will switch to a
                 safer browser if it comes at the cost of significantly
                 degrading web application performance. We present the
                 first information flow tracking JavaScript engine that
                 is based on a true just-in-time compiler, and that
                 thereby outperforms all previous interpreter-based
                 information flow tracking JavaScript engines by more
                 than a factor of two. Our JIT-based engine (i) has the
                 same coverage as previous interpreter- based solutions,
                 (ii) requires reasonable implementation effort, and
                 (iii) introduces new optimizations to achieve
                 acceptable performance. When evaluated against three
                 industry-standard JavaScript benchmark suites, there is
                 still an average slowdown of 73\% over engines that do
                 not support information flow, but this is now well
                 within the range that many users will find an
                 acceptable price for obtaining substantially increased
                 security.",
  acknowledgement = ack-nhfb,
  articleno =    "38",
  fjournal =     "ACM Transactions on Architecture and Code Optimization
                 (TACO)",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J924",
}

@Article{Kienle:2013:BRE,
  author =       "Holger M. Kienle",
  title =        "Book Review: {{\booktitle{Effective JavaScript: 68
                 specific ways to harness the power of JavaScript}} by
                 David Herman}",
  journal =      j-SIGSOFT,
  volume =       "38",
  number =       "6",
  pages =        "40--41",
  month =        nov,
  year =         "2013",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/2532780.2532791",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:16:31 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Leung:2013:PEJ,
  author =       "Alan Leung and Ondrej Lhot{\'a}k and Ghulam Lashari",
  title =        "Parallel execution of {Java} loops on {Graphics
                 Processing Units}",
  journal =      j-SCI-COMPUT-PROGRAM,
  volume =       "78",
  number =       "5",
  pages =        "458--480",
  day =          "1",
  month =        may,
  year =         "2013",
  CODEN =        "SCPGD4",
  ISSN =         "0167-6423 (print), 1872-7964 (electronic)",
  ISSN-L =       "0167-6423",
  bibdate =      "Wed Mar 27 07:52:16 MDT 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/scicomputprogram.bib;
                 http://www.sciencedirect.com/science/journal/01676423",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0167642311001444",
  acknowledgement = ack-nhfb,
  fjournal =     "Science of Computer Programming",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01676423",
}

@Book{Lewis:2013:IAP,
  author =       "Mark C. Lewis",
  title =        "Introduction to the art of programming using {Scala}",
  publisher =    pub-CRC,
  address =      pub-CRC:adr,
  pages =        "????",
  year =         "2013",
  ISBN =         "1-4398-9666-6 (paperback)",
  ISBN-13 =      "978-1-4398-9666-2 (paperback)",
  LCCN =         "QA76.73.S28 L49 2013",
  bibdate =      "Fri Nov 16 06:30:37 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 z3950.loc.gov:7090/Voyager",
  series =       "Chapman and Hall/CRC textbooks in computing",
  acknowledgement = ack-nhfb,
  subject =      "Scala (Computer program language); Textbooks; Computer
                 programming; COMPUTERS / Programming Languages /
                 General.; MATHEMATICS / General.",
}

@Book{Lindholm:2013:JVMa,
  author =       "Tim Lindholm and Frank Yellin and Gilad Bracha and
                 Alex Buckley",
  title =        "The {Java Virtual Machine} Specification",
  publisher =    pub-PH,
  address =      pub-PH:adr,
  edition =      "Third",
  pages =        "????",
  year =         "2013",
  ISBN =         "0-13-326044-5 (paperback)",
  ISBN-13 =      "978-0-13-326044-1 (paperback)",
  LCCN =         "????",
  bibdate =      "Mon Jan 28 14:57:22 MST 2013",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  series =       "The Java series",
  acknowledgement = ack-nhfb,
  subject =      "Java (Computer program language)",
  xxaddress =    "Harlow",
}

@Book{Lindholm:2013:JVMb,
  author =       "Tim Lindholm and Frank Yellin and Gilad Bracha and
                 Alex Buckley",
  title =        "The {Java Virtual Machine} Specification",
  publisher =    pub-AW,
  address =      pub-AW,
  edition =      "{Java SE 7}",
  pages =        "xvii + 587 (est.)",
  year =         "2013",
  ISBN =         "0-13-326049-6, 0-13-326044-5",
  ISBN-13 =      "978-0-13-326049-6, 978-0-13-326044-1",
  LCCN =         "QA76.73.J38 L56 1999",
  bibdate =      "Thu Dec 4 07:52:39 MST 2014",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/mathcw.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  URL =          "http://proquest.tech.safaribooksonline.de/9780133260496",
  acknowledgement = ack-nhfb,
  remark =       "Previous edition: 2nd, 1999.",
  subject =      "Java (Computer program language); Internet; Virtual
                 computer systems; Java (Computer program language);
                 Internet; Virtual computer systems",
}

@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,
  articleno =    "12",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Book{Long:2013:JCG,
  author =       "Fred Long and Dhruv Mohindra and Robert Seacord and
                 Dean Sutherland and David Svoboda",
  title =        "{Java} coding guidelines: 75 recommendations for
                 reliable and secure programs",
  publisher =    pub-AW,
  address =      pub-AW:adr,
  year =         "2013",
  ISBN =         "0-13-343952-6, 0-13-343954-2 (e-book), 0-321-93315-X
                 (paperback)",
  ISBN-13 =      "978-0-13-343952-6, 978-0-13-343954-0 (e-book),
                 978-0-321-93315-7 (paperback)",
  LCCN =         "QA76.73.J38 L664 2014",
  bibdate =      "Wed Apr 15 06:20:13 MDT 2020",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  series =       "The SEI series in software engineering",
  URL =          "http://0proquest.safaribooksonline.com/9780133439526",
  abstract =     "``A must-read for all Java developers. Every developer
                 has a responsibility to author code that is free of
                 significant security vulnerabilities. This book
                 provides realistic guidance to help Java developers
                 implement desired functionality with security,
                 reliability, and maintainability goals in mind.'' --
                 Mary Ann Davidson, Chief Security Officer, Oracle
                 Corporation Organizations worldwide rely on Java code
                 to perform mission-critical tasks, and therefore that
                 code must be reliable, robust, fast, maintainable, and
                 secure. \booktitle{Java Coding Guidelines} brings
                 together expert guidelines, recommendations, and code
                 examples to help you meet these demands. Written by the
                 same team that brought you \booktitle{The CERT Oracle
                 Secure Coding Standard for Java}, this guide extends
                 that previous work's expert security advice to address
                 many additional quality attributes. You'll find 75
                 guidelines, each presented consistently and
                 intuitively. For each guideline, conformance
                 requirements are specified; for most, noncompliant code
                 examples and compliant solutions are also offered. The
                 authors explain when to apply each guideline and
                 provide references to even more detailed information.
                 Reflecting pioneering research on Java security, Java
                 Coding Guidelines offers updated techniques for
                 protecting against both deliberate attacks and other
                 unexpected events. You'll find best practices for
                 improving code reliability and clarity, and a full
                 chapter exposing common misunderstandings that lead to
                 suboptimal code. With a Foreword by James A. Gosling,
                 Father of the Java Programming Language.",
  acknowledgement = ack-nhfb,
  tableofcontents = "Security \\
                 Defensive programming \\
                 Reliability \\
                 Program understandability \\
                 Programmer misconceptions",
}

@Article{Loureiro:2013:EDS,
  author =       "Andr{\'e} Loureiro and Jo{\~a}o Paulo Porto and Guido
                 Araujo",
  title =        "Extending decoupled software pipeline to parallelize
                 {Java} programs",
  journal =      j-SPE,
  volume =       "43",
  number =       "5",
  pages =        "525--541",
  month =        may,
  year =         "2013",
  CODEN =        "SPEXBL",
  DOI =          "https://doi.org/10.1002/spe.2120",
  ISSN =         "0038-0644 (print), 1097-024X (electronic)",
  ISSN-L =       "0038-0644",
  bibdate =      "Sat Apr 27 13:41:04 MDT 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/spe.bib;
                 http://www3.interscience.wiley.com/journalfinder.html",
  acknowledgement = ack-nhfb,
  fjournal =     "Software---Practice and Experience",
  journal-URL =  "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)1097-024X",
  onlinedate =   "15 May 2012",
}

@Article{Malhotra:2013:DFT,
  author =       "Ruchika Malhotra and Divya Tiwari",
  title =        "Development of a framework for test case
                 prioritization using genetic algorithm",
  journal =      j-SIGSOFT,
  volume =       "38",
  number =       "3",
  pages =        "1--6",
  month =        may,
  year =         "2013",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/2464526.2464536",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:16:25 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  abstract =     "Software Testing is a time and effort consuming part
                 of the software development life cycle. Retesting a
                 software application during the maintenance phase, with
                 the entire test suite and additional test cases for the
                 modifications in the software, within budget and time,
                 is a challenge for software testers. Test Case
                 Prioritization is used to overcome this problem by
                 prioritizing the test cases in order to maximize
                 certain testing objectives like fault detection rate,
                 statement coverage, etc. In this paper, we propose a
                 framework for test case prioritization that emphasizes
                 a new metric, APBC$_m$ (modified Average Percentage of
                 Block Coverage). This metric evaluates the rate of code
                 coverage by incorporating knowledge about the
                 significance of blocks of code in the form of weights.
                 We have used this metric as fitness evaluation function
                 in a Genetic Algorithm in order to evaluate the
                 effectiveness of a test case sequence. We have also
                 developed a tool that implements the Genetic Algorithm
                 in the Java language in order to compute and validate
                 the results. Thereafter, we use the tool for test case
                 prioritization, and compare and assess the results with
                 those produced by the tool when APBC (Average
                 Percentage of Block Coverage) is used as fitness
                 function.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Marinescu:2013:FSJ,
  author =       "Maria-Cristina Marinescu and C{\'e}sar S{\'a}nchez",
  title =        "Fusing statecharts and {Java}",
  journal =      j-TECS,
  volume =       "12",
  number =       "1s",
  pages =        "45:1--45:??",
  month =        mar,
  year =         "2013",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/2435227.2435241",
  ISSN =         "1539-9087 (print), 1558-3465 (electronic)",
  ISSN-L =       "1539-9087",
  bibdate =      "Tue Mar 19 07:54:21 MDT 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/tecs.bib",
  abstract =     "This article presents FUSE, an approach for modeling
                 and implementing embedded software components which
                 starts from a main-stream programming language and
                 brings some of the key concepts of Statecharts as
                 first-class elements within this language. Our approach
                 provides a unified programming environment which not
                 only preserves some of the advantages of Statecharts'
                 formal foundation but also directly supports features
                 of object-orientation and strong typing. By specifying
                 Statecharts directly in FUSE we eliminate the
                 out-of-synch between the model and the generated code
                 and we allow the tuning and debugging to be done within
                 the same programming model. This article describes the
                 main language constructs of FUSE and presents its
                 semantics by translation into the Java programming
                 language. We conclude by discussing extensions to the
                 base language which enable the efficient static
                 checking of program properties.",
  acknowledgement = ack-nhfb,
  articleno =    "45",
  fjournal =     "ACM Transactions on Embedded Computing Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?&idx=J840",
}

@Article{Miller:2013:IPG,
  author =       "Heather Miller and Philipp Haller and Eugene Burmako
                 and Martin Odersky",
  title =        "Instant pickles: generating object-oriented pickler
                 combinators for fast and extensible serialization",
  journal =      j-SIGPLAN,
  volume =       "48",
  number =       "10",
  pages =        "183--202",
  month =        oct,
  year =         "2013",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2544173.2509547",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Dec 9 09:19:33 MST 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "OOPSLA '13 conference proceedings.",
  abstract =     "As more applications migrate to the cloud, and as
                 ``big data'' edges into even more production
                 environments, the performance and simplicity of
                 exchanging data between compute nodes/devices is
                 increasing in importance. An issue central to
                 distributed programming, yet often under-considered, is
                 serialization or pickling, i.e., persisting runtime
                 objects by converting them into a binary or text
                 representation. Pickler combinators are a popular
                 approach from functional programming; their
                 composability alleviates some of the tedium of writing
                 pickling code by hand, but they don't translate well to
                 object-oriented programming due to qualities like open
                 class hierarchies and subtyping polymorphism.
                 Furthermore, both functional pickler combinators and
                 popular, Java-based serialization frameworks tend to be
                 tied to a specific pickle format, leaving programmers
                 with no choice of how their data is persisted. In this
                 paper, we present object-oriented pickler combinators
                 and a framework for generating them at compile-time,
                 called scala/pickling, designed to be the default
                 serialization mechanism of the Scala programming
                 language. The static generation of OO picklers enables
                 significant performance improvements, outperforming
                 Java and Kryo in most of our benchmarks. In addition to
                 high performance and the need for little to no
                 boilerplate, our framework is extensible: using the
                 type class pattern, users can provide both (1) custom,
                 easily interchangeable pickle formats and (2) custom
                 picklers, to override the default behavior of the
                 pickling framework. In benchmarks, we compare
                 scala/pickling with other popular industrial
                 frameworks, and present results on time, memory usage,
                 and size when pickling/unpickling a number of data
                 types used in real-world, large-scale distributed
                 applications and frameworks.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Miller:2013:TSG,
  author =       "Mark Miller",
  title =        "A tested semantics for getters, setters, and eval in
                 {JavaScript}",
  journal =      j-SIGPLAN,
  volume =       "48",
  number =       "2",
  pages =        "1--16",
  month =        feb,
  year =         "2013",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2480360.2384579",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Jul 1 17:15:12 MDT 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "We present S5, a semantics for the strict mode of the
                 ECMAScript 5.1 (JavaScript) programming language. S5
                 shrinks the large source language into a manageable
                 core through an implemented transformation. The
                 resulting specification has been tested against
                 real-world conformance suites for the language. This
                 paper focuses on two aspects of S5: accessors (getters
                 and setters) and eval. Since these features are complex
                 and subtle in JavaScript, they warrant special study.
                 Variations on both features are found in several other
                 programming languages, so their study is likely to have
                 broad applicability.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "DLS '12 conference proceedings.",
}

@Article{Misra:2013:JSC,
  author =       "Janardan Misra and Annervaz KM and Vikrant Kaulgud and
                 Shubhashis Sengupta and Gary Titus",
  title =        "{Java} source-code clustering: Unifying syntactic and
                 semantic features",
  journal =      j-SIGSOFT,
  volume =       "38",
  number =       "1",
  pages =        "41--43",
  month =        jan,
  year =         "2013",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/2413038.2382766",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:16:22 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  abstract =     "This is a report from an international workshop on
                 ``Social and Algorithmic Issues in Business Support''
                 (SAIBS), which was organized in conjunction with the
                 16th ADBIS Conference in Poznan, Poland, on September
                 17, 2012. The main focus of this workshop was to
                 provide a venue for the discussion whether social
                 stands in opposition to algorithmic or systematic. We
                 analyzed social contribution to business processes
                 taking into account possible benefits and risk factors.
                 Questions raised in collected research and discussion
                 related to how far business could relay on social input
                 and what were the limits or what were the areas where
                 introducing crowdsourced components might increase
                 overall risk value to unacceptable level? Algorithmic
                 approach to observe and collect social behaviour was
                 discussed in the context of internet auctions
                 participants and car drivers equipped in mobile
                 application for instant route planning and collecting
                 feedback car-tracking data. Having in mind Andrew
                 Keen's critique of social contribution in Web
                 2.0-related phenomena we looked for the Wisdom of
                 Crowds [1]. Collected conclusions and further
                 dissemination of research results should lead to an
                 improvement in utilizing social impact on software
                 development and business processes.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@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,
  articleno =    "14",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Noll:2013:OFD,
  author =       "Albert Noll and Thomas Gross",
  title =        "Online feedback-directed optimizations for parallel
                 {Java} code",
  journal =      j-SIGPLAN,
  volume =       "48",
  number =       "10",
  pages =        "713--728",
  month =        oct,
  year =         "2013",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2544173.2509518",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Dec 9 09:19:33 MST 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  note =         "OOPSLA '13 conference proceedings.",
  abstract =     "The performance of parallel code significantly depends
                 on the parallel task granularity (PTG). If the PTG is
                 too coarse, performance suffers due to load imbalance;
                 if the PTG is too fine, performance suffers from the
                 overhead that is induced by parallel task creation and
                 scheduling. This paper presents a software platform
                 that automatically determines the PTG at run-time.
                 Automatic PTG selection is enabled by concurrent calls,
                 which are special source language constructs that
                 provide a late decision (at run-time) of whether
                 concurrent calls are executed sequentially or
                 concurrently (as a parallel task). Furthermore, the
                 execution semantics of concurrent calls permits the
                 runtime system to merge two (or more) concurrent calls
                 thereby coarsening the PTG. We present an integration
                 of concurrent calls into the Java programming language,
                 the Java Memory Model, and show how the Java Virtual
                 Machine can adapt the PTG based on dynamic profiling.
                 The performance evaluation shows that our runtime
                 system performs competitively to Java programs for
                 which the PTG is tuned manually. Compared to an
                 unfortunate choice of the PTG, this approach performs
                 up to 3x faster than standard Java code.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Nuzman:2013:JTC,
  author =       "Dorit Nuzman and Revital Eres and Sergei Dyshel and
                 Marcel Zalmanovici and Jose Castanos",
  title =        "{JIT} technology with {C\slash C++}: Feedback-directed
                 dynamic recompilation for statically compiled
                 languages",
  journal =      j-TACO,
  volume =       "10",
  number =       "4",
  pages =        "59:1--59:??",
  month =        dec,
  year =         "2013",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/2541228.2555315",
  ISSN =         "1544-3566 (print), 1544-3973 (electronic)",
  ISSN-L =       "1544-3566",
  bibdate =      "Thu Jan 9 10:42:35 MST 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/taco.bib",
  abstract =     "The growing gap between the advanced capabilities of
                 static compilers as reflected in benchmarking results
                 and the actual performance that users experience in
                 real-life scenarios makes client-side dynamic
                 optimization technologies imperative to the domain of
                 static languages. Dynamic optimization of software
                 distributed in the form of a platform-agnostic
                 Intermediate-Representation (IR) has been very
                 successful in the domain of managed languages, greatly
                 improving upon interpreted code, especially when online
                 profiling is used. However, can such feedback-directed
                 IR-based dynamic code generation be viable in the
                 domain of statically compiled, rather than interpreted,
                 languages? We show that fat binaries, which combine the
                 IR together with the statically compiled executable,
                 can provide a practical solution for software vendors,
                 allowing their software to be dynamically optimized
                 without the limitation of binary-level approaches,
                 which lack the high-level IR of the program, and
                 without the warm-up costs associated with the IR-only
                 software distribution approach. We describe and
                 evaluate the fat-binary-based runtime compilation
                 approach using SPECint2006, demonstrating that the
                 overheads it incurs are low enough to be successfully
                 surmounted by dynamic optimization. Building on Java
                 JIT technologies, our results already improve upon
                 common real-world usage scenarios, including very small
                 workloads.",
  acknowledgement = ack-nhfb,
  articleno =    "59",
  fjournal =     "ACM Transactions on Architecture and Code Optimization
                 (TACO)",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J924",
}

@Article{Ogawa:2013:RJA,
  author =       "Yuki Ogawa and Masahiro Iida and Motoki Amagasaki and
                 Morihiro Kuga and Toshinori Sueyoshi",
  title =        "A reconfigurable {Java} accelerator with software
                 compatibility for embedded systems",
  journal =      j-COMP-ARCH-NEWS,
  volume =       "41",
  number =       "5",
  pages =        "71--76",
  month =        dec,
  year =         "2013",
  CODEN =        "CANED2",
  DOI =          "https://doi.org/10.1145/2641361.2641373",
  ISSN =         "0163-5964 (print), 1943-5851 (electronic)",
  ISSN-L =       "0163-5964",
  bibdate =      "Mon Aug 18 17:12:43 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigarch.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGARCH Computer Architecture News",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J89",
}

@Article{Ohkawa:2013:RHO,
  author =       "Takeshi Ohkawa and Daichi Uetake and Takashi Yokota
                 and Kanemitsu Ootsu and Takanobu Baba",
  title =        "Reconfigurable and hardwired {ORB} engine on {FPGA} by
                 {Java-to-HDL} synthesizer for realtime application",
  journal =      j-COMP-ARCH-NEWS,
  volume =       "41",
  number =       "5",
  pages =        "77--82",
  month =        dec,
  year =         "2013",
  CODEN =        "CANED2",
  DOI =          "https://doi.org/10.1145/2641361.2641374",
  ISSN =         "0163-5964 (print), 1943-5851 (electronic)",
  ISSN-L =       "0163-5964",
  bibdate =      "Mon Aug 18 17:12:43 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigarch.bib",
  abstract =     "A platform for networked FPGA system design, which is
                 named ``ORB Engine'', is proposed to add more
                 controllability and design productivity on FPGA-based
                 systems composed of software and hardwired IPs. A
                 developer can define an object-oriented interface for
                 the circuit IP in FPGA, and implement the control
                 sequence part using Java. The circuit IP in FPGA can be
                 handled through object-oriented interface from variety
                 of programming languages like C++, Java, Python, Ruby
                 and so on. Application specific and high-efficiency
                 circuit for ORB (Object Request Broker) protocol
                 processing is synthesized from easy-handling Java code
                 using JavaRock Java-to-HDL synthesizer within the
                 de-facto standard CORBA (Common Object Request Broker
                 Architecture). The measurement result shows a very low
                 latency as low as 200us of UDP/IP packet in/out and
                 exhibits a fluctuation free delay performance, which is
                 desirable for real-time applications.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGARCH Computer Architecture News",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J89",
}

@Article{Parnin:2013:AUJ,
  author =       "Chris Parnin and Christian Bird and Emerson
                 Murphy-Hill",
  title =        "Adoption and use of {Java} generics",
  journal =      j-EMPIR-SOFTWARE-ENG,
  volume =       "18",
  number =       "6",
  pages =        "1047--1089",
  month =        dec,
  year =         "2013",
  CODEN =        "ESENFW",
  DOI =          "https://doi.org/10.1007/s10664-012-9236-6",
  ISSN =         "1382-3256 (print), 1573-7616 (electronic)",
  ISSN-L =       "1382-3256",
  bibdate =      "Fri Dec 2 09:14:30 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/empir-software-eng.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://link.springer.com/accesspage/article/10.1007/s10664-012-9236-6",
  acknowledgement = ack-nhfb,
  fjournal =     "Empirical Software Engineering",
  journal-URL =  "http://link.springer.com/journal/10664",
}

@Article{Plumbridge:2013:BPR,
  author =       "Gary Plumbridge and Jack Whitham and Neil Audsley",
  title =        "{Blueshell}: a platform for rapid prototyping of
                 multiprocessor {NoCs} and accelerators",
  journal =      j-COMP-ARCH-NEWS,
  volume =       "41",
  number =       "5",
  pages =        "107--117",
  month =        dec,
  year =         "2013",
  CODEN =        "CANED2",
  DOI =          "https://doi.org/10.1145/2641361.2641379",
  ISSN =         "0163-5964 (print), 1943-5851 (electronic)",
  ISSN-L =       "0163-5964",
  bibdate =      "Mon Aug 18 17:12:43 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigarch.bib",
  abstract =     "The rapid increase in FPGA logic capacity has enabled
                 the prototyping of multiprocessor Network-on-Chip (NoC)
                 architectures. However, the design space exploration of
                 these complex architectures is highly time consuming
                 with traditional methodologies for FPGA design. Our
                 paper addresses the challenges of multiprocessor
                 network design with the Blueshell framework for
                 generating multiprocessor networks on chip (NoC) and a
                 coupled Java software stack, Network-Chi. With
                 Blueshell hardware is constructed from high-level
                 components including processors and routers using
                 concise Bluespec System Verilog. The Network-Chi
                 software framework is also presented to enable
                 programming the on-chip processors in a familiar Java
                 style and without exposing the low-level systems
                 programming to the application designer. We demonstrate
                 that Blueshell systems with as many as 20 processors
                 can be implemented on a modestly sized FPGA.
                 Performance figures for a selection of distributed
                 applications are also provided.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGARCH Computer Architecture News",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J89",
}

@Article{Puffitsch:2013:SIP,
  author =       "Wolfgang Puffitsch",
  title =        "Special Issue Papers: Design and analysis of a hard
                 real-time garbage collector for a {Java} chip
                 multi-processor",
  journal =      j-CCPE,
  volume =       "25",
  number =       "16",
  pages =        "2269--2289",
  month =        nov,
  year =         "2013",
  CODEN =        "CCPEBO",
  DOI =          "https://doi.org/10.1002/cpe.2921",
  ISSN =         "1532-0626 (print), 1532-0634 (electronic)",
  ISSN-L =       "1532-0626",
  bibdate =      "Tue Dec 3 10:37:44 MST 2013",
  bibsource =    "http://www.interscience.wiley.com/jpages/1532-0626;
                 https://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Concurrency and Computation: Practice and Experience",
  journal-URL =  "http://www.interscience.wiley.com/jpages/1532-0626",
  onlinedate =   "17 Sep 2012",
}

@Article{Pukall:2013:JFR,
  author =       "Mario Pukall and Christian K{\"a}stner and Walter
                 Cazzola and Sebastian G{\"o}tz and Alexander Grebhahn
                 and Reimar Schr{\"o}ter and Gunter Saake",
  title =        "{JavAdaptor} ---Flexible runtime updates of {Java}
                 applications",
  journal =      j-SPE,
  volume =       "43",
  number =       "2",
  pages =        "153--185",
  month =        feb,
  year =         "2013",
  CODEN =        "SPEXBL",
  DOI =          "https://doi.org/10.1002/spe.2107",
  ISSN =         "0038-0644 (print), 1097-024X (electronic)",
  ISSN-L =       "0038-0644",
  bibdate =      "Thu Mar 7 08:19:39 MST 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/spe.bib;
                 http://www3.interscience.wiley.com/journalfinder.html",
  acknowledgement = ack-nhfb,
  fjournal =     "Software---Practice and Experience",
  journal-URL =  "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)1097-024X",
  onlinedate =   "17 Feb 2012",
}

@Article{Ramos:2013:DSJ,
  author =       "Sabela Ramos and Guillermo L. Taboada and Roberto R.
                 Exp{\'o}sito and Juan Touri{\~n}o and Ram{\'o}n
                 Doallo",
  title =        "Design of Scalable {Java} Communication Middleware for
                 Multi-Core Systems",
  journal =      j-COMP-J,
  volume =       "56",
  number =       "2",
  pages =        "214--228",
  month =        feb,
  year =         "2013",
  CODEN =        "CMPJA6",
  DOI =          "https://doi.org/10.1093/comjnl/bxs122",
  ISSN =         "0010-4620 (print), 1460-2067 (electronic)",
  ISSN-L =       "0010-4620",
  bibdate =      "Sat Feb 2 06:33:23 MST 2013",
  bibsource =    "http://comjnl.oxfordjournals.org/content/56/2.toc;
                 https://www.math.utah.edu/pub/tex/bib/compj2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://comjnl.oxfordjournals.org/content/56/2/214.full.pdf+html",
  acknowledgement = ack-nhfb,
  fjournal =     "Computer Journal",
  journal-URL =  "http://comjnl.oxfordjournals.org/",
  onlinedate =   "September 5, 2012",
}

@Article{Ravn:2013:EIS,
  author =       "Anders P. Ravn and M. Teresa Higuera-Toledano",
  title =        "Editorials: Introduction to the special issue on
                 {Java} technologies for real-time and embedded systems:
                 {JTRES2011}",
  journal =      j-CCPE,
  volume =       "25",
  number =       "16",
  pages =        "2225--2226",
  month =        nov,
  year =         "2013",
  CODEN =        "CCPEBO",
  DOI =          "https://doi.org/10.1002/cpe.3023",
  ISSN =         "1532-0626 (print), 1532-0634 (electronic)",
  ISSN-L =       "1532-0626",
  bibdate =      "Tue Dec 3 10:37:44 MST 2013",
  bibsource =    "http://www.interscience.wiley.com/jpages/1532-0626;
                 https://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Concurrency and Computation: Practice and Experience",
  journal-URL =  "http://www.interscience.wiley.com/jpages/1532-0626",
  onlinedate =   "29 Apr 2013",
}

@Book{Rayns:2013:CJS,
  author =       "Chris Rayns and others",
  title =        "{CICS} and the {JVM} server developing and deploying
                 {Java} applications",
  publisher =    "IBM Corporation, International Technical Support
                 Organization",
  address =      "Poughkeepsie, NY, USA",
  pages =        "????",
  year =         "2013",
  ISBN =         "0-7384-3833-2",
  ISBN-13 =      "978-0-7384-3833-7",
  LCCN =         "????",
  bibdate =      "Thu Dec 4 08:14:09 MST 2014",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  series =       "IBM redbooks",
  URL =          "http://proquest.tech.safaribooksonline.de/0738438332",
  acknowledgement = ack-nhfb,
  subject =      "CICS (Syst{\`e}me informatique); Java (Langage de
                 programmation); Logiciels d'application;
                 D{\'e}veloppement; Syst{\`e}mes virtuels
                 (Informatique); CICS (Computer system); Java (Computer
                 program language); Application software; Development;
                 Virtual computer systems; Development.; CICS (Computer
                 system); Java (Computer program language); Virtual
                 computer systems.",
}

@Article{Reynolds:2013:MJB,
  author =       "Mark C. Reynolds",
  title =        "Modeling the {Java Bytecode Verifier}",
  journal =      j-SCI-COMPUT-PROGRAM,
  volume =       "78",
  number =       "3",
  pages =        "327--342",
  day =          "1",
  month =        mar,
  year =         "2013",
  CODEN =        "SCPGD4",
  DOI =          "https://doi.org/10.1016/j.scico.2011.03.008",
  ISSN =         "0167-6423 (print), 1872-7964 (electronic)",
  ISSN-L =       "0167-6423",
  bibdate =      "Sat Jan 5 18:54:31 MST 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/scicomputprogram.bib;
                 http://www.sciencedirect.com/science/journal/01676423",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0167642311000943",
  acknowledgement = ack-nhfb,
  fjournal =     "Science of Computer Programming",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01676423",
}

@Article{Ricci:2013:ETP,
  author =       "Nathan P. Ricci and Samuel Z. Guyer and J. Eliot B.
                 Moss",
  title =        "{Elephant Tracks}: portable production of complete and
                 precise {GC} traces",
  journal =      j-SIGPLAN,
  volume =       "48",
  number =       "11",
  pages =        "109--118",
  month =        nov,
  year =         "2013",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2555670.2466484",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Dec 9 08:04:34 MST 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "ISMM '13 conference proceedings.",
  abstract =     "We present Elephant Tracks (ET), a dynamic program
                 analysis tool for Java that produces detailed traces of
                 garbage collection-related events, including object
                 allocations, object deaths, and pointer updates. Like
                 prior work, our tracing tool is based on the Merlin
                 algorithm [6,7], but offers several substantial new
                 capabilities. First, it is much more precise than
                 previous tools: it traces method entries and exits and
                 measures time in terms of them, allowing it to place
                 events precisely in the context of the program
                 structure. Second, it is implemented using a
                 combination of JVM Tool Interface (JVMTI)[13] callbacks
                 and bytecode rewriting, and works with any standard
                 JVM. Finally, it produces complete traces, including
                 weak references, events from the Java Native Interface
                 and sun.misc.Unsafe, and VM start up objects. In this
                 paper we also explore the general design space of
                 tracing tools, and carefully define the execution model
                 that the traces represent.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Richards:2013:FAC,
  author =       "Gregor Richards and Christian Hammer and Francesco
                 Zappa Nardelli and Suresh Jagannathan and Jan Vitek",
  title =        "Flexible access control for {JavaScript}",
  journal =      j-SIGPLAN,
  volume =       "48",
  number =       "10",
  pages =        "305--322",
  month =        oct,
  year =         "2013",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2544173.2509542",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Dec 9 09:19:33 MST 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "OOPSLA '13 conference proceedings.",
  abstract =     "Providing security guarantees for systems built out of
                 untrusted components requires the ability to define and
                 enforce access control policies over untrusted code. In
                 Web 2.0 applications, JavaScript code from different
                 origins is often combined on a single page, leading to
                 well-known vulnerabilities. We present a security
                 infrastructure which allows users and content providers
                 to specify access control policies over subsets of a
                 JavaScript program by leveraging the concept of
                 delimited histories with revocation. We implement our
                 proposal in WebKit and evaluate it with three policies
                 on 50 widely used websites with no changes to their
                 JavaScript code and report performance overheads and
                 violations.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Salkeld:2013:IDO,
  author =       "Robin Salkeld and Gregor Kiczales",
  title =        "Interacting with dead objects",
  journal =      j-SIGPLAN,
  volume =       "48",
  number =       "10",
  pages =        "203--216",
  month =        oct,
  year =         "2013",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2544173.2509543",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Dec 9 09:19:33 MST 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  note =         "OOPSLA '13 conference proceedings.",
  abstract =     "Debugging and analyzing a snapshot of a crashed
                 program's memory is far more difficult than working
                 with a live program, because debuggers can no longer
                 execute code to help make sense of the program state.
                 We present an architecture that supports the restricted
                 execution of ordinary code starting from the snapshot,
                 as if the dead objects within it had been restored, but
                 without access to their original external environment.
                 We demonstrate the feasibility of this approach via an
                 implementation for Java that does not require a custom
                 virtual machine, show that it performs competitively
                 with live execution, and use it to diagnose an
                 unresolved memory leak in a mature mainstream
                 application.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Santos:2013:DDS,
  author =       "Ivo Santos and Marcel Tilly and Badrish Chandramouli
                 and Jonathan Goldstein",
  title =        "{DiAl}: distributed streaming analytics anywhere,
                 anytime",
  journal =      j-PROC-VLDB-ENDOWMENT,
  volume =       "6",
  number =       "12",
  pages =        "1386--1389",
  month =        aug,
  year =         "2013",
  CODEN =        "????",
  ISSN =         "2150-8097",
  bibdate =      "Fri Dec 13 05:57:00 MST 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/vldbe.bib",
  abstract =     "Connected devices are expected to grow to 50 billion
                 in 2020. Through our industrial partners and their use
                 cases, we validated the importance of inflight data
                 processing to produce results with low latency, in
                 particular local and global data analytics
                 capabilities. In order to cope with the scalability
                 challenges posed by distributed streaming analytics
                 scenarios, we propose two new technologies: (1)
                 JStreams, a low footprint and efficient JavaScript
                 complex event processing engine supporting local
                 analytics on heterogeneous devices and (2) DiAlM, a
                 distributed analytics management service that leverages
                 cloud-edge evolving topologies. In the demonstration,
                 based on a real manufacturing use case, we walk through
                 a situation where operators supervise manufacturing
                 equipment through global analytics, and drill down into
                 alarm cases on the factory floor by locally inspecting
                 the data generated by the manufacturing equipment.",
  acknowledgement = ack-nhfb,
  fjournal =     "Proceedings of the VLDB Endowment",
}

@MastersThesis{Schmeisser:2013:MOE,
  author =       "Michael Schmei{\ss}er",
  title =        "{Metriken und optimale Einsatzszenarien f{\"u}r
                 Garbage Collectoren der Java HotSpot Virtual Machine}.
                 ({German}) [{Metrics} and best use scenarios for
                 garbage collectors of the {Java HotSpot Virtual
                 Machine}]",
  type =         "Masterarbeit",
  school =       "Hochschule f{\"u}r Technik, Wirtschaft und Kultur",
  address =      "Leipzig, Germany",
  pages =        "iii + 103",
  year =         "2013",
  bibdate =      "Thu Dec 04 08:18:41 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  acknowledgement = ack-nhfb,
  language =     "German",
}

@Book{Seth:2013:UJV,
  author =       "Sachin Seth",
  title =        "Understanding {Java Virtual Machine}",
  publisher =    "Alpha Science International",
  address =      "Oxford, UK",
  pages =        "318",
  year =         "2013",
  ISBN =         "1-84265-815-8",
  ISBN-13 =      "978-1-84265-815-4",
  LCCN =         "QA76.73.J38 S437 2013",
  bibdate =      "Thu Dec 4 13:23:14 MST 2014",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/mathcw.bib",
  acknowledgement = ack-nhfb,
  shorttableofcontents = "Preface \\
                 Platform Dependency and Virtualization \\
                 Class File Format \\
                 Designing Platform Independent Language \\
                 JVM Internal Data Structure \\
                 JVM Instruction Set \\
                 General Algorithm of Java Virtual Machines \\
                 Understanding Java Native Interface \\
                 Implementing JNI Functions \\
                 Multithreading in Java \\
                 Garbage Collection",
  subject =      "Java virtual machine; Java virtual machine.; Virtual
                 computer systems; Virtual computer systems.",
  tableofcontents = "1. Platform Dependency and Virtualization \\
                 1.1. Introduction \\
                 1.2. How Programs Are Platform Dependent \\
                 1.2.1. Windows Segmented Executable File Format \\
                 1.2.2. {\tt a.out} (File Format) \\
                 1.2.3. Executable and Linking Format (ELF) \\
                 1.3. How Platform Independence is Achieved \\
                 1.3.1. Hardware Virtual Machines \\
                 1.3.2. Application Virtual Machines \\
                 1.3.3. Machine Aggregation \\
                 1.4. Java Virtual Machine \\
                 1.5. Why Byte Codes \\
                 2. Class File Format \\
                 2.1. Introduction \\
                 2.2. Signature or Magic Byte \\
                 2.3. Major and Minor Version Number \\
                 2.4. Constant Pool Count \\
                 2.5. Constant Pool Table \\
                 2.5.1. Constant\_Utf8 \\
                 2.5.2. Constant\_Integer and Constant\_Float \\
                 2.5.3. Constant\_Long and Constant\_Double \\
                 2.5.4. Constant\_Class \\
                 2.5.5. Constant\_String \\
                 2.5.6. Constant\_Fieldref, Constant\_Methodref,
                 Constant\_InterfaceMethodref \\
                 2.5.7. Constant\_NameAndType \\
                 2.6. Access Flags \\
                 2.7. This\_class \\
                 2.8. super\_class \\
                 2.9. Interface\_count \\
                 2.10. Interfaces table \\
                 2.11. Fields Count \\
                 2.12. Field table \\
                 2.12.1. Access\_Flags \\
                 2.12.2. Name\_Index \\
                 2.12.3. Descriptor\_Index \\
                 2.12.4. Attributes\_Count \\
                 2.12.5. Attributes\_Table \\
                 2.13. Methods count \\
                 2.14. Method table \\
                 2.15. Attributes\_Count \\
                 2.16. Attributes\_table \\
                 2.16.1. Attribute Information Structure \\
                 2.17. Code Attribute \\
                 2.18. Exceptions Attribute \\
                 2.19. C data structure to represent the class file \\
                 2.20. Internal Representation of descriptor \\
                 2.20.1. Field Descriptors \\
                 2.20.2. Method Descriptors \\
                 3. Designing Platform Independent Language \\
                 3.1. Designing Your Own Platform Independent Language
                 \\
                 4. JVM Internal Data Structure \\
                 4.1. Introduction \\
                 4.2. Java Virtual Machine Data Types \\
                 4.2.1. Integral Types \\
                 4.2.2. Floating Point Types \\
                 4.2.3. Return Address Type \\
                 4.2.4. Boolean Type \\
                 4.2.5. Reference Type \\
                 4.3. JVM Data Types Storage Area \\
                 4.4. JVM Internal Data Structures \\
                 4.4.1. The pc Register \\
                 4.4.2. Class Heap \\
                 4.4.3. Object Heap \\
                 4.4.4. Array Heap \\
                 4.4.5. Stack Frame \\
                 4.4.6. Method Area \\
                 4.4.7. Operand Stack \\
                 5. JVM Instruction Set \\
                 5.1. Introduction \\
                 5.2. Virtual Machine Error \\
                 5.3. Operations Involved in Executing Instructions \\
                 5.3.1. Push and Pop on Operand Stack \\
                 5.3.2. Push and Pop on Parameter Stack \\
                 5.3.3. Creating Function Stack Frame \\
                 5.3.4. Retrieving and Storing Values in Function Stack
                 Frame \\
                 5.3.5. Creating an Object of Class \\
                 5.3.6. Storing Field Value \\
                 5.3.7. Getting Field Value \\
                 5.3.8. Allocating Memory for Static Fields \\
                 5.3.9. Storing Static Field Values \\
                 5.3.10. Get Static Field Values \\
                 5.3.11. Creating Array \\
                 5.3.12. Creating the Muti-dimensional Array \\
                 5.3.13. Storing and Retrieving Value from Array \\
                 5.3.14. Executing a Method \\
                 5.3.15. Throw an Exception \\
                 5.3.16. Acquiring Monitor \\
                 5.3.17. Releasing Monitor \\
                 5.3.18. Constant\_utf8 to String \\
                 5.4. Instruction Set \\
                 6. General Algorithm Of Java Virtual Machines \\
                 6.1. What Happens Behind the Scene \\
                 6.1.1. Loading of Class \\
                 6.1.2. Verification of Class \\
                 6.1.3. Preparation of Class \\
                 6.1.4. Resolution of Symbols \\
                 6.1.5. Initialization \\
                 6.1.6. Initialize System Class Function \\
                 6.1.7. Load and Execute Test Class Class \\
                 6.2. Changes in JVM's Internal Data Structure \\
                 7. Understanding Java Native Interface \\
                 7.1. Why JNI \\
                 7.2. JNI Interface Functions \\
                 7.3. Loading and Linking Native Library \\
                 7.4. Referencing Java Objects \\
                 7.5. JNI Types and Data Structures \\
                 7.6. JNI by Example \\
                 7.7. JNI behind the Scene \\
                 7.7.1. Calling Native Function from Java \\
                 7.7.2. Calling Java Function from Native Language \\
                 8. Implementing JNI Functions \\
                 8.1. JNI Function Table \\
                 8.2. Initializing JNI Environment \\
                 8.3. JNI Helper Functions \\
                 8.3.1. Call Method \\
                 8.3.2. Call Method A0 \\
                 8.3.3. Call Static Method 0 \\
                 8.3.4. Call Static Method A0 \\
                 8.3.5. Release Array Elements 0 \\
                 8.3.6. Add to Local Ref List \\
                 8.4. JNI Functions \\
                 8.4.1. GetVersion \\
                 8.4.2. DefineClass \\
                 8.4.3. Find Class \\
                 8.4.4. GetSuperclass \\
                 8.4.5. Is Assignable From \\
                 8.4.6. Throw \\
                 8.4.7. ThrowNew \\
                 8.4.8. Throws \\
                 8.4.9. Exception Describe \\
                 8.4.10. Exception Clear \\
                 8.4.11. Fatal Error \\
                 8.4.12. New Local Ref \\
                 8.4.13. New Global Ref \\
                 8.4.14. New Weak Global Ref \\
                 8.4.15. Delete Global Ref \\
                 8.4.16. Delete Local Ref \\
                 8.4.17. Delete Weak Local Ref \\
                 8.4.18. AllocObject \\
                 8.4.19. New Object, New ObjectA and New ObjectV \\
                 8.4.20. Get Object Class \\
                 8.4.21. Is Instance Of \\
                 8.4.22. Is Same Object \\
                 8.4.23. Get Field ID \\
                 8.4.24. Get<type>Field \\
                 8.4.25. Set<type>Field \\
                 8.4.26. Get Method ID \\
                 8.4.27. Call<type>Method \\
                 8.4.28. Call Nonvirtual<type>Method \\
                 8.4.29. Get Static Field ID \\
                 8.4.30. Get Static<type>Field Routines \\
                 8.4.31. Set Static<type>Field Routines \\
                 8.4.32. Get Static Method ID \\
                 8.4.33. Call Static<type>Method \\
                 8.4.34. New String \\
                 8.4.35. Get String Length \\
                 8.4.36. Get String Region \\
                 8.4.37. Get String Chars \\
                 8.4.38. Get String Critical \\
                 8.4.39. Release String Chars \\
                 8.4.40. Release String Critical \\
                 8.4.41. New String UTF \\
                 8.4.42. Get String UTF Chars \\
                 8.4.43. Get String UTF Region \\
                 8.4.44. Get String UTF Length \\
                 8.4.45. Release String UTF Chars \\
                 8.4.46. Get Array Length \\
                 8.4.47. New Object Array \\
                 8.4.48. Get Object Array Element \\
                 8.4.49. Set Object Array Element \\
                 8.4.50. New<PrimitiveType>Array \\
                 8.4.51. Get<PrimitiveType>ArrayElements Routines \\
                 8.4.52. Release<PrimitiveType>ArrayElements Routines
                 \\
                 8.4.53. Get<PrimitiveType>ArrayRegion Routines \\
                 8.4.54. Set<PrimitiveType>ArrayRegion Routines \\
                 8.4.55. Register Natives \\
                 8.4.56. Unregister Natives \\
                 8.4.57. Push Local Frame \\
                 8.4.58. Pop Local Frame \\
                 8.4.59. Monitor Enter \\
                 8.4.60. Monitor Exit \\
                 8.4.61. Get Java VM \\
                 9. Multithreading In Java \\
                 9.1. Introduction \\
                 9.2. Multithreading in Java \\
                 9.3. Memory Model for Thread \\
                 9.4. Creating Thread in Java \\
                 9.5. Why Multithreading in Java is Platform Dependent?
                 \\
                 9.5.1. Sleep() \\
                 9.5.2. Stop() \\
                 9.5.3. Suspend() \\
                 9.5.4. Resume() \\
                 9.5.5. isAlive() \\
                 9.5.6. Interrupt() \\
                 9.5.7. Join() \\
                 9.5.8. Yield() \\
                 9.5.9. SetPriority() \\
                 9.6. Thread local storage \\
                 9.7. Volatile keyword \\
                 9.8. Thread Synchronization in Java \\
                 10. Garbage Collection \\
                 10.1. Introduction \\
                 10.2. Drawbacks of Legacy Languages \\
                 10.3. Solution to Memory Leak in Java \\
                 10.4. How JVM Recognizes that an Object is not Being
                 Referenced",
}

@Article{Singh:2013:TGC,
  author =       "Pavitdeep Singh and Satwinder Singh and Jatinder
                 Kaur",
  title =        "Tool for generating code metrics for {C\#} source code
                 using abstract syntax tree technique",
  journal =      j-SIGSOFT,
  volume =       "38",
  number =       "5",
  pages =        "1--6",
  month =        sep,
  year =         "2013",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/2507288.2507312",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:16:29 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/csharp.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  abstract =     "Software maintenance is one of the key activities in
                 any software engineering process in which source code
                 analysis plays a crucial role. Due to the high cost of
                 maintenance, it has become quite necessary to produce
                 high quality software. Over time, numerous analyses
                 have been performed on source code to determine
                 complexity and other metrics. Lots of papers have been
                 published for object oriented languages but mostly
                 concentrating on C++ and Java, very few has been
                 published for more modern languages like C\#. This
                 paper proposes a Software Quality Assurance Tool for
                 measuring the different code metrics for the object
                 oriented language C\# at the class and method levels.
                 The technique consists of generating the abstract
                 syntax tree of the source code using Nfactory
                 libraries. The Interface is built using the Win Form
                 application which provides an impressive GUI for the
                 tool.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Smaragdakis:2013:SBP,
  author =       "Yannis Smaragdakis and George Balatsouras and George
                 Kastrinis",
  title =        "Set-based pre-processing for points-to analysis",
  journal =      j-SIGPLAN,
  volume =       "48",
  number =       "10",
  pages =        "253--270",
  month =        oct,
  year =         "2013",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2544173.2509524",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Dec 9 09:19:33 MST 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "OOPSLA '13 conference proceedings.",
  abstract =     "We present set-based pre-analysis: a virtually
                 universal optimization technique for flow-insensitive
                 points-to analysis. Points-to analysis computes a
                 static abstraction of how object values flow through a
                 program's variables. Set-based pre-analysis relies on
                 the observation that much of this reasoning can take
                 place at the set level rather than the value level.
                 Computing constraints at the set level results in
                 significant optimization opportunities: we can rewrite
                 the input program into a simplified form with the same
                 essential points-to properties. This rewrite results in
                 removing both local variables and instructions, thus
                 simplifying the subsequent value-based points-to
                 computation. Effectively, set-based pre-analysis puts
                 the program in a normal form optimized for points-to
                 analysis. Compared to other techniques for off-line
                 optimization of points-to analyses in the literature,
                 the new elements of our approach are the ability to
                 eliminate statements, and not just variables, as well
                 as its modularity: set-based pre-analysis can be
                 performed on the input just once, e.g., allowing the
                 pre-optimization of libraries that are subsequently
                 reused many times and for different analyses. In
                 experiments with Java programs, set-based pre-analysis
                 eliminates 30\% of the program's local variables and
                 30\% or more of computed context-sensitive points-to
                 facts, over a wide set of benchmarks and analyses,
                 resulting in a ~20\% average speedup (max: 110\%,
                 median: 18\%).",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Stefik:2013:EIP,
  author =       "Andreas Stefik and Susanna Siebert",
  title =        "An Empirical Investigation into Programming Language
                 Syntax",
  journal =      j-TOCE,
  volume =       "13",
  number =       "4",
  pages =        "19:1--19:??",
  month =        nov,
  year =         "2013",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/2534973",
  ISSN =         "1946-6226",
  bibdate =      "Wed Nov 13 17:27:51 MST 2013",
  bibsource =    "http://www.acm.org/pubs/toce;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/python.bib;
                 https://www.math.utah.edu/pub/tex/bib/toce.bib",
  abstract =     "Recent studies in the literature have shown that
                 syntax remains a significant barrier to novice computer
                 science students in the field. While this syntax
                 barrier is known to exist, whether and how it varies
                 across programming languages has not been carefully
                 investigated. For this article, we conducted four
                 empirical studies on programming language syntax as
                 part of a larger analysis into the, so called,
                 programming language wars. We first present two surveys
                 conducted with students on the intuitiveness of syntax,
                 which we used to garner formative clues on what words
                 and symbols might be easy for novices to understand. We
                 followed up with two studies on the accuracy rates of
                 novices using a total of six programming languages:
                 Ruby, Java, Perl, Python, Randomo, and Quorum. Randomo
                 was designed by randomly choosing some keywords from
                 the ASCII table (a metaphorical placebo). To our
                 surprise, we found that languages using a more
                 traditional C-style syntax (both Perl and Java) did not
                 afford accuracy rates significantly higher than a
                 language with randomly generated keywords, but that
                 languages which deviate (Quorum, Python, and Ruby) did.
                 These results, including the specifics of syntax that
                 are particularly problematic for novices, may help
                 teachers of introductory programming courses in
                 choosing appropriate first languages and in helping
                 students to overcome the challenges they face with
                 syntax.",
  acknowledgement = ack-nhfb,
  articleno =    "19",
  fjournal =     "ACM Transactions on Computing Education",
}

@Article{Sun:2013:BJW,
  author =       "Mengtao Sun and Gang Tan and Joseph Siefers and Bin
                 Zeng and Greg Morrisett",
  title =        "Bringing {Java}'s wild native world under control",
  journal =      j-TISSEC,
  volume =       "16",
  number =       "3",
  pages =        "9:1--9:??",
  month =        nov,
  year =         "2013",
  CODEN =        "ATISBQ",
  DOI =          "https://doi.org/10.1145/2535505",
  ISSN =         "1094-9224 (print), 1557-7406 (electronic)",
  ISSN-L =       "1094-9224",
  bibdate =      "Mon Dec 9 11:22:22 MST 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/tissec.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  abstract =     "For performance and for incorporating legacy
                 libraries, many Java applications contain native-code
                 components written in unsafe languages such as C and
                 C++. Native-code components interoperate with Java
                 components through the Java Native Interface (JNI). As
                 native code is not regulated by Java's security model,
                 it poses serious security threats to the managed Java
                 world. We introduce a security framework that extends
                 Java's security model and brings native code under
                 control. Leveraging software-based fault isolation, the
                 framework puts native code in a separate sandbox and
                 allows the interaction between the native world and the
                 Java world only through a carefully designed pathway.
                 Two different implementations were built. In one
                 implementation, the security framework is integrated
                 into a Java Virtual Machine (JVM). In the second
                 implementation, the framework is built outside of the
                 JVM and takes advantage of JVM-independent interfaces.
                 The second implementation provides JVM portability, at
                 the expense of some performance degradation. Evaluation
                 of our framework demonstrates that it incurs modest
                 runtime overhead while significantly enhancing the
                 security of Java applications.",
  acknowledgement = ack-nhfb,
  articleno =    "9",
  fjournal =     "ACM Transactions on Information and System Security",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J789",
}

@Article{Taboada:2013:JHP,
  author =       "Guillermo L. Taboada and Sabela Ramos and Roberto R.
                 Exp{\'o}sito and Juan Touri{\~n}o and Ram{\'o}n
                 Doallo",
  title =        "{Java} in the {High Performance Computing} arena:
                 Research, practice and experience",
  journal =      j-SCI-COMPUT-PROGRAM,
  volume =       "78",
  number =       "5",
  pages =        "425--444",
  day =          "1",
  month =        may,
  year =         "2013",
  CODEN =        "SCPGD4",
  ISSN =         "0167-6423 (print), 1872-7964 (electronic)",
  ISSN-L =       "0167-6423",
  bibdate =      "Wed Mar 27 07:52:16 MDT 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/scicomputprogram.bib;
                 http://www.sciencedirect.com/science/journal/01676423",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0167642311001420",
  acknowledgement = ack-nhfb,
  fjournal =     "Science of Computer Programming",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01676423",
}

@Article{Taft:2013:TPS,
  author =       "S. Tucker Taft",
  title =        "Tutorial: proving safety of parallel \slash
                 multi-threaded programs",
  journal =      j-SIGADA-LETTERS,
  volume =       "33",
  number =       "3",
  pages =        "1--2",
  month =        dec,
  year =         "2013",
  CODEN =        "AALEE5",
  DOI =          "https://doi.org/10.1145/2658982.2527285",
  ISSN =         "1094-3641 (print), 1557-9476 (electronic)",
  ISSN-L =       "1094-3641",
  bibdate =      "Wed Sep 3 16:38:30 MDT 2014",
  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/sigada.bib",
  abstract =     "This tutorial will introduce the attendees to analysis
                 and proof techniques for programs using parallelism and
                 multi-threading. There are no specific prerequisites,
                 but a familiarity with the notions of preconditions and
                 postconditions, aliasing, race conditions, and
                 deadlocks would be of value. The examples will be based
                 on the threading and parallelism models of Java, Ada,
                 and two new parallel languages, one called ParaSail [4]
                 and another, inspired by the verifiable SPARK[1][2]
                 subset of Ada, called Sparkel[3]. We will introduce the
                 distinction between safety and liveness properties, and
                 then focus primarily on techniques for the verification
                 of safety properties, including the absence of race
                 conditions and deadlocks. We will also discuss the
                 issue of determinism vs. non-determinism in parallel
                 and multi-threaded programs.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGADA Ada Letters",
  journal-URL =  "http://portal.acm.org/citation.cfm?id=J32",
  remark =       "HILT '13 conference proceedings.",
}

@Article{Taibi:2013:ROS,
  author =       "Fathi Taibi",
  title =        "Reusability of open-source program code: a conceptual
                 model and empirical investigation",
  journal =      j-SIGSOFT,
  volume =       "38",
  number =       "4",
  pages =        "1--5",
  month =        jul,
  year =         "2013",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/2492248.2492276",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:16:27 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/gnu.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  abstract =     "Reusing program modules is one of the most direct and
                 useful ways to develop cost effective software,
                 especially with the availability of huge amounts of
                 open-source projects. Reuse saves cost, increases the
                 speed of development and improves software reliability.
                 The quality of popular open-source packages is good as
                 shown by various empirical studies. However, the
                 quality of less known packages and the large number of
                 projects developed by programming enthusiasts is
                 unknown. Reusing them may be the source of more
                 problems rather than being a solution to a problem. In
                 this paper, a conceptual model is proposed to measure
                 the reusability of program modules. A balanced set of
                 well-established metrics is used to compute the most
                 significant factors of reusability and an empirical
                 investigation is conducted to measure the reusability
                 of the modules of randomly selected open-source Java
                 projects. The results obtained are thoroughly analyzed
                 to discover the real reusability potential of
                 open-source program code together with suggestions on
                 how to improve this potential.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Teodorovici:2013:BRL,
  author =       "Vasile G. Teodorovici",
  title =        "Book Review: {{\booktitle{Learning JavaScript: a
                 hands-on guide to the fundamentals of modern
                 JavaScript}} by Tim Wright}",
  journal =      j-SIGSOFT,
  volume =       "38",
  number =       "3",
  pages =        "35--36",
  month =        may,
  year =         "2013",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/2464526.2464554",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:16:25 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Terra:2013:QCC,
  author =       "Ricardo Terra and Luis Fernando Miranda and Marco
                 Tulio Valente and Roberto S. Bigonha",
  title =        "Qualitas.class corpus: a compiled version of the
                 qualitas corpus",
  journal =      j-SIGSOFT,
  volume =       "38",
  number =       "5",
  pages =        "1--4",
  month =        sep,
  year =         "2013",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/2507288.2507314",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:16:29 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  abstract =     "This paper documents a compiled version of the
                 Qualitas Corpus named Qualitas.class Corpus. We provide
                 compiled Java projects for the 111 systems included in
                 the corpus. We also gathered a large amount of metrics
                 data (such as measurements from complexity, coupling,
                 and CK metrics) about the systems. By making
                 Qualitas.class Corpus public, our goal is to assist
                 researchers by removing the compilation effort when
                 conducting empirical studies.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Tetali:2013:MSA,
  author =       "Sai Deep Tetali and Mohsen Lesani and Rupak Majumdar
                 and Todd Millstein",
  title =        "{MrCrypt}: static analysis for secure cloud
                 computations",
  journal =      j-SIGPLAN,
  volume =       "48",
  number =       "10",
  pages =        "271--286",
  month =        oct,
  year =         "2013",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2544173.2509554",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Dec 9 09:19:33 MST 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/cryptography2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "OOPSLA '13 conference proceedings.",
  abstract =     "In a common use case for cloud computing, clients
                 upload data and computation to servers that are managed
                 by a third-party infrastructure provider. We describe
                 MrCrypt, a system that provides data confidentiality in
                 this setting by executing client computations on
                 encrypted data. MrCrypt statically analyzes a program
                 to identify the set of operations on each input data
                 column, in order to select an appropriate homomorphic
                 encryption scheme for that column, and then transforms
                 the program to operate over encrypted data. The
                 encrypted data and transformed program are uploaded to
                 the server and executed as usual, and the result of the
                 computation is decrypted on the client side. We have
                 implemented MrCrypt for Java and illustrate its
                 practicality on three standard benchmark suites for the
                 Hadoop MapReduce framework. We have also formalized the
                 approach and proven several soundness and security
                 guarantees.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Ureche:2013:MIS,
  author =       "Vlad Ureche and Cristian Talau and Martin Odersky",
  title =        "Miniboxing: improving the speed to code size tradeoff
                 in parametric polymorphism translations",
  journal =      j-SIGPLAN,
  volume =       "48",
  number =       "10",
  pages =        "73--92",
  month =        oct,
  year =         "2013",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2544173.2509537",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Dec 9 09:19:33 MST 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  note =         "OOPSLA '13 conference proceedings.",
  abstract =     "Parametric polymorphism enables code reuse and type
                 safety. Underneath the uniform interface exposed to
                 programmers, however, its low level implementation has
                 to cope with inherently non-uniform data: value types
                 of different sizes and semantics (bytes, integers,
                 floating point numbers) and reference types (pointers
                 to heap objects). On the Java Virtual Machine,
                 parametric polymorphism is currently translated to
                 bytecode using two competing approaches: homogeneous
                 and heterogeneous. Homogeneous translation requires
                 boxing, and thus introduces indirect access delays.
                 Heterogeneous translation duplicates and adapts code
                 for each value type individually, producing more
                 bytecode. Therefore bytecode speed and size are at odds
                 with each other. This paper proposes a novel
                 translation that significantly reduces the bytecode
                 size without affecting the execution speed. The key
                 insight is that larger value types (such as integers)
                 can hold smaller ones (such as bytes) thus reducing the
                 duplication necessary in heterogeneous translations. In
                 our implementation, on the Scala compiler, we encode
                 all primitive value types in long integers. The
                 resulting bytecode approaches the performance of
                 monomorphic code, matches the performance of the
                 heterogeneous translation and obtains speedups of up to
                 22x over the homogeneous translation, all with modest
                 increases in size.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Wimmer:2013:MAV,
  author =       "Christian Wimmer and Michael Haupt and Michael L. {Van
                 De Vanter} and Mick Jordan and Laurent Dayn{\`e}s and
                 Douglas Simon",
  title =        "{Maxine}: an approachable virtual machine for, and in,
                 {Java}",
  journal =      j-TACO,
  volume =       "9",
  number =       "4",
  pages =        "30:1--30:??",
  month =        jan,
  year =         "2013",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/2400682.2400689",
  ISSN =         "1544-3566 (print), 1544-3973 (electronic)",
  ISSN-L =       "1544-3566",
  bibdate =      "Fri Jan 18 10:57:16 MST 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/taco.bib",
  abstract =     "A highly productive platform accelerates the
                 production of research results. The design of a Virtual
                 Machine (VM) written in the Java{\TM} programming
                 language can be simplified through exploitation of
                 interfaces, type and memory safety, automated memory
                 management (garbage collection), exception handling,
                 and reflection. Moreover, modern Java IDEs offer
                 time-saving features such as refactoring,
                 auto-completion, and code navigation. Finally, Java
                 annotations enable compiler extensions for low-level
                 ``systems programming'' while retaining IDE
                 compatibility. These techniques collectively make
                 complex system software more ``approachable'' than has
                 been typical in the past. The Maxine VM, a metacircular
                 Java VM implementation, has aggressively used these
                 features since its inception. A co-designed companion
                 tool, the Maxine Inspector, offers integrated debugging
                 and visualization of all aspects of the VM's runtime
                 state. The Inspector's implementation exploits advanced
                 Java language features, embodies intimate knowledge of
                 the VM's design, and even reuses a significant amount
                 of VM code directly. These characteristics make Maxine
                 a highly approachable VM research platform and a
                 productive basis for research and teaching.",
  acknowledgement = ack-nhfb,
  articleno =    "30",
  fjournal =     "ACM Transactions on Architecture and Code Optimization
                 (TACO)",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J924",
}

@Article{Wurthinger:2013:USD,
  author =       "Thomas W{\"u}rthinger and Christian Wimmer and Lukas
                 Stadler",
  title =        "Unrestricted and safe dynamic code evolution for
                 {Java}",
  journal =      j-SCI-COMPUT-PROGRAM,
  volume =       "78",
  number =       "5",
  pages =        "481--498",
  day =          "1",
  month =        may,
  year =         "2013",
  CODEN =        "SCPGD4",
  ISSN =         "0167-6423 (print), 1872-7964 (electronic)",
  ISSN-L =       "0167-6423",
  bibdate =      "Wed Mar 27 07:52:16 MDT 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/scicomputprogram.bib;
                 http://www.sciencedirect.com/science/journal/01676423",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0167642311001456",
  acknowledgement = ack-nhfb,
  fjournal =     "Science of Computer Programming",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01676423",
}

@Article{Xie:2013:AAE,
  author =       "Xinwei Xie and Jingling Xue and Jie Zhang",
  title =        "{Acculock}: accurate and efficient detection of data
                 races",
  journal =      j-SPE,
  volume =       "43",
  number =       "5",
  pages =        "543--576",
  month =        may,
  year =         "2013",
  CODEN =        "SPEXBL",
  DOI =          "https://doi.org/10.1002/spe.2121",
  ISSN =         "0038-0644 (print), 1097-024X (electronic)",
  ISSN-L =       "0038-0644",
  bibdate =      "Sat Apr 27 13:41:04 MDT 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/spe.bib;
                 http://www3.interscience.wiley.com/journalfinder.html",
  acknowledgement = ack-nhfb,
  fjournal =     "Software---Practice and Experience",
  journal-URL =  "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)1097-024X",
  keywords =     "FastTrack; Java; Java Virtual Machine; JIKES; Jikes
                 Research Virtual Machine; RoadRunner",
  onlinedate =   "16 Apr 2012",
}

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

@Article{Yang:2013:CPP,
  author =       "Chao Yang and Zengyou He and Weichuan Yu",
  title =        "A Combinatorial Perspective of the Protein Inference
                 Problem",
  journal =      j-TCBB,
  volume =       "10",
  number =       "6",
  pages =        "1542--1547",
  month =        nov,
  year =         "2013",
  CODEN =        "ITCBCY",
  DOI =          "https://doi.org/10.1109/TCBB.2013.110",
  ISSN =         "1545-5963 (print), 1557-9964 (electronic)",
  ISSN-L =       "1545-5963",
  bibdate =      "Fri Feb 28 05:26:07 MST 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/tcbb.bib",
  abstract =     "In a shotgun proteomics experiment, proteins are the
                 most biologically meaningful output. The success of
                 proteomics studies depends on the ability to accurately
                 and efficiently identify proteins. Many methods have
                 been proposed to facilitate the identification of
                 proteins from peptide identification results. However,
                 the relationship between protein identification and
                 peptide identification has not been thoroughly
                 explained before. In this paper, we devote ourselves to
                 a combinatorial perspective of the protein inference
                 problem. We employ combinatorial mathematics to
                 calculate the conditional protein probabilities
                 (protein probability means the probability that a
                 protein is correctly identified) under three
                 assumptions, which lead to a lower bound, an upper
                 bound, and an empirical estimation of protein
                 probabilities, respectively. The combinatorial
                 perspective enables us to obtain an analytical
                 expression for protein inference. Our method achieves
                 comparable results with ProteinProphet in a more
                 efficient manner in experiments on two data sets of
                 standard protein mixtures and two data sets of real
                 samples. Based on our model, we study the impact of
                 unique peptides and degenerate peptides (degenerate
                 peptides are peptides shared by at least two proteins)
                 on protein probabilities. Meanwhile, we also study the
                 relationship between our model and ProteinProphet. We
                 name our program ProteinInfer. Its Java source code,
                 our supplementary document and experimental results are
                 available at
                 http://bioinformatics.ust.hk/proteininfer.",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE/ACM Transactions on Computational Biology and
                 Bioinformatics",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J954",
}

@Article{Yiapanis:2013:OSR,
  author =       "Paraskevas Yiapanis and Demian Rosas-Ham and Gavin
                 Brown and Mikel Luj{\'a}n",
  title =        "Optimizing software runtime systems for speculative
                 parallelization",
  journal =      j-TACO,
  volume =       "9",
  number =       "4",
  pages =        "39:1--39:??",
  month =        jan,
  year =         "2013",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/2400682.2400698",
  ISSN =         "1544-3566 (print), 1544-3973 (electronic)",
  ISSN-L =       "1544-3566",
  bibdate =      "Fri Jan 18 10:57:16 MST 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/taco.bib",
  abstract =     "Thread-Level Speculation (TLS) overcomes limitations
                 intrinsic with conservative compile-time
                 auto-parallelizing tools by extracting parallel threads
                 optimistically and only ensuring absence of data
                 dependence violations at runtime. A significant barrier
                 for adopting TLS (implemented in software) is the
                 overheads associated with maintaining speculative
                 state. Based on previous TLS limit studies, we observe
                 that on future multicore systems we will likely have
                 more cores idle than those which traditional TLS would
                 be able to harness. This implies that a TLS system
                 should focus on optimizing for small number of cores
                 and find efficient ways to take advantage of the idle
                 cores. Furthermore, research on optimistic systems has
                 covered two important implementation design points:
                 eager vs. lazy version management. With this knowledge,
                 we propose new simple and effective techniques to
                 reduce the execution time overheads for both of these
                 design points. This article describes a novel compact
                 version management data structure optimized for space
                 overhead when using a small number of TLS threads.
                 Furthermore, we describe two novel software runtime
                 parallelization systems that utilize this compact data
                 structure. The first software TLS system, MiniTLS,
                 relies on eager memory data management (in-place
                 updates) and, thus, when a misspeculation occurs a
                 rollback process is required. MiniTLS takes advantage
                 of the novel compact version management representation
                 to parallelize the rollback process and is able to
                 recover from misspeculation faster than existing
                 software eager TLS systems. The second one, Lector
                 (Lazy inspECTOR) is based on lazy version management.
                 Since we have idle cores, the question is whether we
                 can create ``helper'' tasks to determine whether
                 speculation is actually needed without stopping or
                 damaging the speculative execution. In Lector, for each
                 conventional TLS thread running speculatively with lazy
                 version management, there is associated with it a
                 lightweight inspector. The inspector threads execute
                 alongside to verify quickly whether data dependencies
                 will occur. Inspector threads are generated by standard
                 techniques for inspector/executor parallelization. We
                 have applied both TLS systems to seven Java sequential
                 benchmarks, including three benchmarks from
                 SPECjvm2008. Two out of the seven benchmarks exhibit
                 misspeculations. MiniTLS experiments report average
                 speedups of 1.8x for 4 threads increasing close to 7x
                 speedups with 32 threads. Facilitated by our novel
                 compact representation, MiniTLS reduces the space
                 overhead over state-of-the-art software TLS systems
                 between 96\% on 2 threads and 40\% on 32 threads. The
                 experiments for Lector, report average speedups of 1.7x
                 for 2 threads (that is 1 TLS + 1 Inspector threads)
                 increasing close to 8.2x speedups with 32 threads (16 +
                 16 threads). Compared to a well established software
                 TLS baseline, Lector performs on average 1.7x faster
                 for 32 threads and in no case ( x TLS + x Inspector
                 threads) Lector delivers worse performance than the
                 baseline TLS with the equivalent number of TLS threads
                 (i.e. x TLS threads) nor doubling the equivalent number
                 of TLS threads (i.e., x + x TLS threads).",
  acknowledgement = ack-nhfb,
  articleno =    "39",
  fjournal =     "ACM Transactions on Architecture and Code Optimization
                 (TACO)",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J924",
}

@Article{Yue:2013:MSI,
  author =       "Chuan Yue and Haining Wang",
  title =        "A measurement study of insecure {JavaScript} practices
                 on the {Web}",
  journal =      j-TWEB,
  volume =       "7",
  number =       "2",
  pages =        "7:1--7:??",
  month =        may,
  year =         "2013",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/2460383.2460386",
  ISSN =         "1559-1131 (print), 1559-114X (electronic)",
  ISSN-L =       "1559-1131",
  bibdate =      "Thu Mar 13 08:28:18 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/tweb.bib",
  abstract =     "JavaScript is an interpreted programming language most
                 often used for enhancing webpage interactivity and
                 functionality. It has powerful capabilities to interact
                 with webpage documents and browser windows, however, it
                 has also opened the door for many browser-based
                 security attacks. Insecure engineering practices of
                 using JavaScript may not directly lead to security
                 breaches, but they can create new attack vectors and
                 greatly increase the risks of browser-based attacks. In
                 this article, we present the first measurement study on
                 insecure practices of using JavaScript on the Web. Our
                 focus is on the insecure practices of JavaScript
                 inclusion and dynamic generation, and we examine their
                 severity and nature on 6,805 unique websites. Our
                 measurement results reveal that insecure JavaScript
                 practices are common at various websites: (1) at least
                 66.4\% of the measured websites manifest the insecure
                 practices of including JavaScript files from external
                 domains into the top-level documents of their webpages;
                 (2) over 44.4\% of the measured websites use the
                 dangerous eval() function to dynamically generate and
                 execute JavaScript code on their webpages; and (3) in
                 JavaScript dynamic generation, using the
                 document.write() method and the innerHTML property is
                 much more popular than using the relatively secure
                 technique of creating script elements via DOM methods.
                 Our analysis indicates that safe alternatives to these
                 insecure practices exist in common cases and ought to
                 be adopted by website developers and administrators for
                 reducing potential security risks.",
  acknowledgement = ack-nhfb,
  articleno =    "7",
  fjournal =     "ACM Transactions on the Web (TWEB)",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J1062",
}

@Article{Zhang:2013:IMF,
  author =       "Lingming Zhang and Lu Zhang and Sarfraz Khurshid",
  title =        "Injecting mechanical faults to localize developer
                 faults for evolving software",
  journal =      j-SIGPLAN,
  volume =       "48",
  number =       "10",
  pages =        "765--784",
  month =        oct,
  year =         "2013",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2544173.2509551",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Dec 9 09:19:33 MST 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "OOPSLA '13 conference proceedings.",
  abstract =     "This paper presents a novel methodology for localizing
                 faults in code as it evolves. Our insight is that the
                 essence of failure-inducing edits made by the developer
                 can be captured using mechanical program
                 transformations (e.g., mutation changes). Based on the
                 insight, we present the FIFL framework, which uses both
                 the spectrum information of edits (obtained using the
                 existing FaultTracer approach) as well as the potential
                 impacts of edits (simulated by mutation changes) to
                 achieve more accurate fault localization. We evaluate
                 FIFL on real-world repositories of nine Java projects
                 ranging from 5.7KLoC to 88.8KLoC. The experimental
                 results show that FIFL is able to outperform the
                 state-of-the-art FaultTracer technique for localizing
                 failure-inducing program edits significantly. For
                 example, all 19 FIFL strategies that use both the
                 spectrum information and simulated impact information
                 for each edit outperform the existing FaultTracer
                 approach statistically at the significance level of
                 0.01. In addition, FIFL with its default settings
                 outperforms FaultTracer by 2.33\% to 86.26\% on 16 of
                 the 26 studied version pairs, and is only inferior than
                 FaultTracer on one version pair.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Zhao:2013:INT,
  author =       "Jisheng Zhao and Roberto Lublinerman and Zoran
                 Budimli{\'c} and Swarat Chaudhuri and Vivek Sarkar",
  title =        "Isolation for nested task parallelism",
  journal =      j-SIGPLAN,
  volume =       "48",
  number =       "10",
  pages =        "571--588",
  month =        oct,
  year =         "2013",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2544173.2509534",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Dec 9 09:19:33 MST 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "OOPSLA '13 conference proceedings.",
  abstract =     "Isolation--the property that a task can access shared
                 data without interference from other tasks--is one of
                 the most basic concerns in parallel programming.
                 Whilethere is a large body of past work on isolated
                 task-parallelism, the integration of isolation,
                 task-parallelism, and nesting of tasks has been a
                 difficult and unresolved challenge. In this pa- per, we
                 present a programming and execution model called Otello
                 where isolation is extended to arbitrarily nested
                 parallel tasks with irregular accesses to heap data. At
                 the same time, no additional burden is imposed on the
                 programmer, who only exposes parallelism by creating
                 and synchronizing parallel tasks, leaving the job of
                 ensuring isolation to the underlying compiler and
                 runtime system. Otello extends our past work on Aida
                 execution model and the delegated isolation mechanism
                 [22] to the setting of nested parallelism. The basic
                 runtime construct in Aida and Otello is an assembly: a
                 task equipped with a region in the shared heap that it
                 owns. When an assembly A conflicts with an assembly B,
                 A transfers--or delegates--its code and owned region to
                 a carefully selected assembly C in a way that will
                 ensure isolation with B, leaving the responsibility of
                 re-executing task A to C. The choice of C depends on
                 the nesting relationship between A and B.We have
                 implemented Otello on top of the Habanero Java (HJ)
                 parallel programming language [8], and used this
                 implementation to evaluate Otello on collections of
                 nested task-parallel benchmarks and non-nested
                 transactional benchmarks from past work. On the nested
                 task-parallel benchmarks, Otello achieves scalability
                 comparable to HJ programs without built-in isolation,
                 and the relative overhead of Otello is lower than that
                 of many published data-race detection algorithms that
                 detect the isolation violations (but do not enforce
                 isolation). For the transactional benchmarks, Otello
                 incurs lower overhead than a state-of-the-art software
                 transactional memory system (Deuce STM).",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Zhu:2013:EAZ,
  author =       "Daming Zhu and Lusheng Wang",
  title =        "An Exact Algorithm for the Zero Exemplar Breakpoint
                 Distance Problem",
  journal =      j-TCBB,
  volume =       "10",
  number =       "6",
  pages =        "1469--1477",
  month =        nov,
  year =         "2013",
  CODEN =        "ITCBCY",
  DOI =          "https://doi.org/10.1109/TCBB.2013.127",
  ISSN =         "1545-5963 (print), 1557-9964 (electronic)",
  ISSN-L =       "1545-5963",
  bibdate =      "Fri Feb 28 05:26:07 MST 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/tcbb.bib",
  abstract =     "The exemplar breakpoint distance problem is one of the
                 most important problems in genome comparison and has
                 been extensively studied in the literature. The
                 exemplar breakpoint distance problem cannot be
                 approximated within any factor even if each gene family
                 occurs at most twice in a genome. This is due to the
                 fact that its decision version, the zero exemplar
                 breakpoint distance problem where each gene family
                 occurs at most twice in a genome (ZEBD$ ((2, 2)) $ for
                 short) is NP-hard. Thus, the basic version ZEBD$ ((2,
                 2)) $ has attracted the attention of many scientists.
                 The best existing algorithm for ZEBD$ ((2, 2)) $ runs
                 in $ (O(n2^n)) $ time. In this paper, we propose a new
                 algorithm for ZEBD$ ((2, 2)) $ with running time $
                 (O(n^{21.86121^n})) $. We have implemented the
                 algorithm in Java. The software package is available
                 upon request.",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE/ACM Transactions on Computational Biology and
                 Bioinformatics",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J954",
}

@Article{Adalid:2014:USA,
  author =       "Dami{\'a}n Adalid and Alberto Salmer{\'o}n and
                 Mar{\'\i}a del Mar Gallardo and Pedro Merino",
  title =        "Using {SPIN} for automated debugging of infinite
                 executions of {Java} programs",
  journal =      j-J-SYST-SOFTW,
  volume =       "90",
  number =       "??",
  pages =        "61--75",
  month =        apr,
  year =         "2014",
  CODEN =        "JSSODM",
  ISSN =         "0164-1212 (print), 1873-1228 (electronic)",
  ISSN-L =       "0164-1212",
  bibdate =      "Thu Mar 6 08:15:03 MST 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/jsystsoftw.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0164121213002641",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Systems and Software",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01641212/",
}

@Article{Ahn:2014:IJP,
  author =       "Wonsun Ahn and Jiho Choi and Thomas Shull and
                 Mar{\'\i}a J. Garzar{\'a}n and Josep Torrellas",
  title =        "Improving {JavaScript} performance by deconstructing
                 the type system",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "6",
  pages =        "496--507",
  month =        jun,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2666356.2594332",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Sep 26 07:38:28 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Increased focus on JavaScript performance has resulted
                 in vast performance improvements for many benchmarks.
                 However, for actual code used in websites, the attained
                 improvements often lag far behind those for popular
                 benchmarks. This paper shows that the main reason
                 behind this short-fall is how the compiler understands
                 types. JavaScript has no concept of types, but the
                 compiler assigns types to objects anyway for ease of
                 code generation. We examine the way that the Chrome V8
                 compiler defines types, and identify two design
                 decisions that are the main reasons for the lack of
                 improvement: (1) the inherited prototype object is part
                 of the current object's type definition, and (2) method
                 bindings are also part of the type definition. These
                 requirements make types very unpredictable, which
                 hinders type specialization by the compiler. Hence, we
                 modify V8 to remove these requirements, and use it to
                 compile the JavaScript code assembled by JSBench from
                 real websites. On average, we reduce the execution time
                 of JSBench by 36\%, and the dynamic instruction count
                 by 49\%.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  received =     "PLDI '14 conference proceedings.",
}

@Article{Altidor:2014:RJG,
  author =       "John Altidor and Yannis Smaragdakis",
  title =        "Refactoring {Java} generics by inferring wildcards, in
                 practice",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "10",
  pages =        "271--290",
  month =        oct,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2714064.2660203",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue May 12 17:41:21 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Wildcard annotations can improve the generality of
                 Java generic libraries, but require heavy manual
                 effort. We present an algorithm for refactoring and
                 inferring more general type instantiations of Java
                 generics using wildcards. Compared to past approaches,
                 our work is practical and immediately applicable: we
                 assume no changes to the Java type system, while taking
                 into account all its intricacies. Our system allows
                 users to select declarations (variables, method
                 parameters, return types, etc.) to generalize and
                 considers declarations not declared in available source
                 code. It then performs an inter-procedural flow
                 analysis and a method body analysis, in order to
                 generalize type signatures. We evaluate our technique
                 on six Java generic libraries. We find that 34\% of
                 available declarations of variant type signatures can
                 be generalized --- i.e., relaxed with more general
                 wildcard types. On average, 146 other declarations need
                 to be updated when a declaration is generalized,
                 showing that this refactoring would be too tedious and
                 error-prone to perform manually.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '14 conference proceedings.",
}

@Article{Andersen:2014:PLJ,
  author =       "J. S. Andersen",
  title =        "Privacy Leaks in {Java} Classes",
  journal =      j-ADA-USER-J,
  volume =       "35",
  number =       "3",
  pages =        "191--??",
  month =        sep,
  year =         "2014",
  CODEN =        "AUJOET",
  ISSN =         "1381-6551",
  ISSN-L =       "1381-6551",
  bibdate =      "Fri Feb 13 06:03:37 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/adauserj.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Ada User Journal",
  journal-URL =  "http://www.ada-europe.org/auj/archive",
}

@Article{Andreasen:2014:DSA,
  author =       "Esben Andreasen and Anders M{\o}ller",
  title =        "Determinacy in static analysis for {jQuery}",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "10",
  pages =        "17--31",
  month =        oct,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2714064.2660214",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue May 12 17:41:21 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Static analysis for JavaScript can potentially help
                 programmers find errors early during development.
                 Although much progress has been made on analysis
                 techniques, a major obstacle is the prevalence of
                 libraries, in particular jQuery, which apply
                 programming patterns that have detrimental consequences
                 on the analysis precision and performance. Previous
                 work on dynamic determinacy analysis has demonstrated
                 how information about program expressions that always
                 resolve to a fixed value in some call context may lead
                 to significant scalability improvements of static
                 analysis for such code. We present a static dataflow
                 analysis for JavaScript that infers and exploits
                 determinacy information on-the-fly, to enable analysis
                 of some of the most complex parts of jQuery. The
                 analysis combines selective context and path
                 sensitivity, constant propagation, and branch pruning,
                 based on a systematic investigation of the main causes
                 of analysis imprecision when using a more basic
                 analysis. The techniques are implemented in the TAJS
                 analysis tool and evaluated on a collection of small
                 programs that use jQuery. Our results show that the
                 proposed analysis techniques boost both precision and
                 performance, specifically for inferring type
                 information and call graphs.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '14 conference proceedings.",
}

@Article{Anonymous:2014:RKS,
  author =       "Anonymous",
  title =        "Release the Kraken: a Story of {{\tt Node.js}} in the
                 Enterprise {(PayPal)}",
  journal =      j-QUEUE,
  volume =       "12",
  number =       "2",
  pages =        "80",
  month =        feb,
  year =         "2014",
  CODEN =        "AQCUAE",
  DOI =          "https://doi.org/10.1145/2578508.2602531",
  ISSN =         "1542-7730 (print), 1542-7749 (electronic)",
  ISSN-L =       "1542-7730",
  bibdate =      "Wed May 21 11:03:43 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/queue.bib",
  abstract =     "A case study in how PayPal revitalized its tech stack
                 by moving from Java, JSP and proprietary solutions to a
                 Node.js web application stack with dust.js templating.
                 Developer agility was our primary motivation, but along
                 the way we had to tackle enterprise culture and teach
                 people that JavaScript is no longer a ''toy'', but a
                 powerful tool to wield.
                 https://vimeo.com/nodesummit/review/85785820/40c2a4811a",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM Queue: Tomorrow's Computing Today",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?&idx=J882",
}

@Article{Balland:2014:ESP,
  author =       "Emilie Balland and Pierre-Etienne Moreau and Antoine
                 Reilles",
  title =        "Effective strategic programming for {Java}
                 developers",
  journal =      j-SPE,
  volume =       "44",
  number =       "2",
  pages =        "129--162",
  month =        feb,
  year =         "2014",
  CODEN =        "SPEXBL",
  DOI =          "https://doi.org/10.1002/spe.2159",
  ISSN =         "0038-0644 (print), 1097-024X (electronic)",
  ISSN-L =       "0038-0644",
  bibdate =      "Thu Jan 23 06:00:41 MST 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/spe.bib;
                 http://www3.interscience.wiley.com/journalfinder.html",
  acknowledgement = ack-nhfb,
  fjournal =     "Software --- Practice and Experience",
  journal-URL =  "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)1097-024X",
  onlinedate =   "4 Oct 2012",
}

@Article{Barr:2014:TAT,
  author =       "Earl T. Barr and Mark Marron",
  title =        "{Tardis}: affordable time-travel debugging in managed
                 runtimes",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "10",
  pages =        "67--82",
  month =        oct,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2714064.2660209",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue May 12 17:41:21 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Developers who set a breakpoint a few statements too
                 late or who are trying to diagnose a subtle bug from a
                 single core dump often wish for a time-traveling
                 debugger. The ability to rewind time to see the exact
                 sequence of statements and program values leading to an
                 error has great intuitive appeal but, due to large time
                 and space overheads, time traveling debuggers have seen
                 limited adoption. A managed runtime, such as the Java
                 JVM or a JavaScript engine, has already paid much of
                 the cost of providing core features --- type safety,
                 memory management, and virtual IO --- that can be
                 reused to implement a low overhead time-traveling
                 debugger. We leverage this insight to design and build
                 affordable time-traveling debuggers for managed
                 languages. Tardis realizes our design: it provides
                 affordable time-travel with an average overhead of only
                 7\% during normal execution, a rate of 0.6MB/s of
                 history logging, and a worst-case 0.68s time-travel
                 latency on our benchmark applications. Tardis can also
                 debug optimized code using time-travel to reconstruct
                 state. This capability, coupled with its low overhead,
                 makes Tardis suitable for use as the default debugger
                 for managed languages, promising to bring
                 time-traveling debugging into the mainstream and
                 transform the practice of debugging.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '14 conference proceedings.",
}

@Article{Basanta-Val:2014:RMP,
  author =       "Pablo Basanta-Val and Marisol Garc{\'\i}a-Valls",
  title =        "Resource management policies for real-time {Java}
                 remote invocations",
  journal =      j-J-PAR-DIST-COMP,
  volume =       "74",
  number =       "1",
  pages =        "1930--1944",
  month =        jan,
  year =         "2014",
  CODEN =        "JPDCER",
  ISSN =         "0743-7315 (print), 1096-0848 (electronic)",
  ISSN-L =       "0743-7315",
  bibdate =      "Wed Dec 11 14:13:24 MST 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/jpardistcomp.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0743731513001378",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Parallel and Distributed Computing",
  journal-URL =  "http://www.sciencedirect.com/science/journal/07437315/",
}

@Article{Basanta-Val:2014:SDG,
  author =       "Pablo Basanta-Val and Marisol Garc{\'\i}a-Valls",
  title =        "A simple distributed garbage collector for distributed
                 real-time {Java}",
  journal =      j-J-SUPERCOMPUTING,
  volume =       "70",
  number =       "3",
  pages =        "1588--1616",
  month =        dec,
  year =         "2014",
  CODEN =        "JOSUED",
  DOI =          "https://doi.org/10.1007/s11227-014-1259-x",
  ISSN =         "0920-8542 (print), 1573-0484 (electronic)",
  ISSN-L =       "0920-8542",
  bibdate =      "Fri Feb 13 12:13:22 MST 2015",
  bibsource =    "http://springerlink.metapress.com/openurl.asp?genre=issue&issn=0920-8542&volume=70&issue=3;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/jsuper.bib",
  URL =          "http://link.springer.com/article/10.1007/s11227-014-1259-x",
  acknowledgement = ack-nhfb,
  fjournal =     "The Journal of Supercomputing",
  journal-URL =  "http://link.springer.com/journal/11227",
}

@Article{Bell:2014:PID,
  author =       "Jonathan Bell and Gail Kaiser",
  title =        "{Phosphor}: illuminating dynamic data flow in
                 commodity {JVMs}",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "10",
  pages =        "83--101",
  month =        oct,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2714064.2660212",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue May 12 17:41:21 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  abstract =     "Dynamic taint analysis is a well-known information
                 flow analysis problem with many possible applications.
                 Taint tracking allows for analysis of application data
                 flow by assigning labels to data, and then propagating
                 those labels through data flow. Taint tracking systems
                 traditionally compromise among performance, precision,
                 soundness, and portability. Performance can be
                 critical, as these systems are often intended to be
                 deployed to production environments, and hence must
                 have low overhead. To be deployed in security-conscious
                 settings, taint tracking must also be sound and
                 precise. Dynamic taint tracking must be portable in
                 order to be easily deployed and adopted for real world
                 purposes, without requiring recompilation of the
                 operating system or language interpreter, and without
                 requiring access to application source code. We present
                 Phosphor, a dynamic taint tracking system for the Java
                 Virtual Machine (JVM) that simultaneously achieves our
                 goals of performance, soundness, precision, and
                 portability. Moreover, to our knowledge, it is the
                 first portable general purpose taint tracking system
                 for the JVM. We evaluated Phosphor 's performance on
                 two commonly used JVM languages (Java and Scala), on
                 two successive revisions of two commonly used JVMs
                 (Oracle's HotSpot and OpenJDK's IcedTea) and on
                 Android's Dalvik Virtual Machine, finding its
                 performance to be impressive: as low as 3\% (53\% on
                 average; 220\% at worst) using the DaCapo macro
                 benchmark suite. This paper describes our approach
                 toward achieving portable taint tracking in the JVM.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '14 conference proceedings.",
}

@Article{Biswas:2014:DES,
  author =       "Swarnendu Biswas and Jipeng Huang and Aritra Sengupta
                 and Michael D. Bond",
  title =        "{DoubleChecker}: efficient sound and precise atomicity
                 checking",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "6",
  pages =        "28--39",
  month =        jun,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2666356.2594323",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Sep 26 07:38:28 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  abstract =     "Atomicity is a key correctness property that allows
                 programmers to reason about code regions in isolation.
                 However, programs often fail to enforce atomicity
                 correctly, leading to atomicity violations that are
                 difficult to detect. Dynamic program analysis can
                 detect atomicity violations based on an atomicity
                 specification, but existing approaches slow programs
                 substantially. This paper presents DoubleChecker, a
                 novel sound and precise atomicity checker whose key
                 insight lies in its use of two new cooperating dynamic
                 analyses. Its imprecise analysis tracks cross-thread
                 dependences soundly but imprecisely with significantly
                 better performance than a fully precise analysis. Its
                 precise analysis is more expensive but only needs to
                 process a subset of the execution identified as
                 potentially involved in atomicity violations by the
                 imprecise analysis. If DoubleChecker operates in
                 single-run mode, the two analyses execute in the same
                 program run, which guarantees soundness and precision
                 but requires logging program accesses to pass from the
                 imprecise to the precise analysis. In multi-run mode,
                 the first program run executes only the imprecise
                 analysis, and a second run executes both analyses.
                 Multi-run mode trades accuracy for performance; each
                 run of multi-run mode outperforms single-run mode, but
                 can potentially miss violations. We have implemented
                 DoubleChecker and an existing state-of-the-art
                 atomicity checker called Velodrome in a
                 high-performance Java virtual machine. DoubleChecker's
                 single-run mode significantly outperforms Velodrome,
                 while still providing full soundness and precision.
                 DoubleChecker's multi-run mode improves performance
                 further, without significantly impacting soundness in
                 practice. These results suggest that DoubleChecker's
                 approach is a promising direction for improving the
                 performance of dynamic atomicity checking over prior
                 work.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  received =     "PLDI '14 conference proceedings.",
}

@Article{Bodin:2014:TMJ,
  author =       "Martin Bodin and Arthur Chargueraud and Daniele
                 Filaretti and Philippa Gardner and Sergio Maffeis and
                 Daiva Naudziuniene and Alan Schmitt and Gareth Smith",
  title =        "A trusted mechanised {JavaScript} specification",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "1",
  pages =        "87--100",
  month =        jan,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2578855.2535876",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Mar 4 17:04:57 MST 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "POPL '14 conference proceedings.",
  abstract =     "JavaScript is the most widely used web language for
                 client-side applications. Whilst the development of
                 JavaScript was initially just led by implementation,
                 there is now increasing momentum behind the ECMA
                 standardisation process. The time is ripe for a formal,
                 mechanised specification of JavaScript, to clarify
                 ambiguities in the ECMA standards, to serve as a
                 trusted reference for high-level language compilation
                 and JavaScript implementations, and to provide a
                 platform for high-assurance proofs of language
                 properties. We present JSCert, a formalisation of the
                 current ECMA standard in the Coq proof assistant, and
                 JSRef, a reference interpreter for JavaScript extracted
                 from Coq to OCaml. We give a Coq proof that JSRef is
                 correct with respect to JSCert and assess JSRef using
                 test262, the ECMA conformance test suite. Our
                 methodology ensures that JSCert is a comparatively
                 accurate formulation of the English standard, which
                 will only improve as time goes on. We have demonstrated
                 that modern techniques of mechanised specification can
                 handle the complexity of JavaScript.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Bosboom:2014:SCC,
  author =       "Jeffrey Bosboom and Sumanaruban Rajadurai and Weng-Fai
                 Wong and Saman Amarasinghe",
  title =        "{StreamJIT}: a commensal compiler for high-performance
                 stream programming",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "10",
  pages =        "177--195",
  month =        oct,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2714064.2660236",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue May 12 17:41:21 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "There are many domain libraries, but despite the
                 performance benefits of compilation, domain-specific
                 languages are comparatively rare due to the high cost
                 of implementing an optimizing compiler. We propose
                 commensal compilation, a new strategy for compiling
                 embedded domain-specific languages by reusing the
                 massive investment in modern language virtual machine
                 platforms. Commensal compilers use the host language's
                 front-end, use host platform APIs that enable back-end
                 optimizations by the host platform JIT, and use an
                 autotuner for optimization selection. The cost of
                 implementing a commensal compiler is only the cost of
                 implementing the domain-specific optimizations. We
                 demonstrate the concept by implementing a commensal
                 compiler for the stream programming language StreamJIT
                 atop the Java platform. Our compiler achieves
                 performance 2.8 times better than the StreamIt native
                 code (via GCC) compiler with considerably less
                 implementation effort.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '14 conference proceedings.",
}

@Article{Bouktif:2014:PSO,
  author =       "Salah Bouktif and Houari Sahraoui and Faheem Ahmed",
  title =        "Predicting Stability of Open-Source Software Systems
                 Using Combination of {Bayesian} Classifiers",
  journal =      j-TMIS,
  volume =       "5",
  number =       "1",
  pages =        "3:1--3:??",
  month =        apr,
  year =         "2014",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/2555596",
  ISSN =         "2158-656X (print), 2158-6578 (electronic)",
  ISSN-L =       "2158-656X",
  bibdate =      "Tue Apr 15 17:44:19 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tmis/;
                 https://www.math.utah.edu/pub/tex/bib/gnu.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/tmis.bib",
  abstract =     "The use of free and Open-Source Software (OSS) systems
                 is gaining momentum. Organizations are also now
                 adopting OSS, despite some reservations, particularly
                 about the quality issues. Stability of software is one
                 of the main features in software quality management
                 that needs to be understood and accurately predicted.
                 It deals with the impact resulting from software
                 changes and argues that stable components lead to a
                 cost-effective software evolution. Changes are most
                 common phenomena present in OSS in comparison to
                 proprietary software. This makes OSS system evolution a
                 rich context to study and predict stability. Our
                 objective in this work is to build stability prediction
                 models that are not only accurate but also
                 interpretable, that is, able to explain the link
                 between the architectural aspects of a software
                 component and its stability behavior in the context of
                 OSS. Therefore, we propose a new approach based on
                 classifiers combination capable of preserving
                 prediction interpretability. Our approach is
                 classifier-structure dependent. Therefore, we propose a
                 particular solution for combining Bayesian classifiers
                 in order to derive a more accurate composite classifier
                 that preserves interpretability. This solution is
                 implemented using a genetic algorithm and applied in
                 the context of an OSS large-scale system, namely the
                 standard Java API. The empirical results show that our
                 approach outperforms state-of-the-art approaches from
                 both machine learning and software engineering.",
  acknowledgement = ack-nhfb,
  articleno =    "3",
  fjournal =     "ACM Transactions on Management Information Systems
                 (TMIS)",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J1320",
}

@Book{Brandt:2014:DAS,
  author =       "Siegmund Brandt",
  title =        "Data analysis: statistical and computational methods
                 for scientists and engineers",
  publisher =    pub-SV,
  address =      pub-SV:adr,
  edition =      "Fourth",
  pages =        "????",
  year =         "2014",
  DOI =          "https://doi.org/10.1007/978-3-319-03762-2",
  ISBN =         "3-319-03762-5 (e-book)",
  ISBN-13 =      "978-3-319-03762-2 (e-book), 978-3-319-03761-5,
                 978-3-319-03761-5",
  LCCN =         "QA273; QA273",
  bibdate =      "Sun May 4 11:27:21 MDT 2014",
  bibsource =    "catalog.princeton.edu:7090/voyager;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/probstat2010.bib;
                 libraries.colorado.edu:210/INNOPAC",
  abstract =     "The fourth edition of this successful textbook
                 presents a comprehensive introduction to statistical
                 and numerical methods for the evaluation of empirical
                 and experimental data. Equal weight is given to
                 statistical theory and practical problems. The concise
                 mathematical treatment of the subject matter is
                 illustrated by many examples, and for the present
                 edition a library of Java programs has been developed.
                 It comprises methods of numerical data analysis and
                 graphical representation as well as many example
                 programs and solutions to programming problems. The
                 programs (source code, Java classes, and documentation)
                 and extensive appendices to the main text are available
                 for free download from the books page at
                 www.springer.com. Contents Probabilities. Random
                 variables. Random numbers and the Monte Carlo Method.
                 Statistical distributions (binomial, Gauss, Poisson).
                 Samples. Statistical tests. Maximum Likelihood. Least
                 Squares. Regression. Minimization. Analysis of
                 Variance. Time series analysis. Audience The book is
                 conceived both as an introduction and as a work of
                 reference. In particular it addresses itself to
                 students, scientists and practitioners in science and
                 engineering as a help in the analysis of their data in
                 laboratory courses, working for bachelor or master
                 degrees, in thesis work, and in research and
                 professional work. The book is concise, but gives a
                 sufficiently rigorous mathematical treatment of
                 practical statistical methods for data analysis; it can
                 be of great use to all who are involved with data
                 analysis. Physicalia. This lively and erudite treatise
                 covers the theory of the main statistical tools and
                 their practical applications. A first rate university
                 textbook, and good background material for the
                 practicing physicist. Physics Bulletin.",
  acknowledgement = ack-nhfb,
  subject =      "Probabilities; Mathematical statistics",
  tableofcontents = "Introduction \\
                 Probabilities \\
                 Random Variables: Distributions \\
                 Computer-Generated Random Numbers: The Monte Carlo
                 Method \\
                 Some Important Distributions and Theorems \\
                 Samples \\
                 The Method of Maximum Likelihood \\
                 Testing Statistical Hypotheses \\
                 The Method of Least Squares \\
                 Function Minimization \\
                 Analysis of Variance \\
                 Linear and Polynomial Regression \\
                 Time-Series Analysis \\
                 (A) Matrix Calculations \\
                 (B) Combinatorics \\
                 (C) Formulas and Methods for the Computation of
                 Statistical Functions \\
                 (D) The Gamma Function and Related Functions: Methods
                 and Programs for their Computation \\
                 (E) Utility Programs \\
                 (F) The Graphics Class DatanGraphics \\
                 (G) Problems, Hints and Solutions and Programming
                 Problems \\
                 (H) Collection of Formulas \\
                 (I) Statistical Formulas \\
                 List of Computer Programs",
}

@Article{Caserta:2014:JTJ,
  author =       "Pierre Caserta and Olivier Zendra",
  title =        "{JBInsTrace}: a tracer of {Java} and {JRE} classes at
                 basic-block granularity by dynamically instrumenting
                 bytecode",
  journal =      j-SCI-COMPUT-PROGRAM,
  volume =       "79",
  number =       "??",
  pages =        "116--125",
  day =          "1",
  month =        jan,
  year =         "2014",
  CODEN =        "SCPGD4",
  ISSN =         "0167-6423 (print), 1872-7964 (electronic)",
  ISSN-L =       "0167-6423",
  bibdate =      "Sat Nov 30 15:06:12 MST 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/scicomputprogram.bib;
                 http://www.sciencedirect.com/science/journal/01676423",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0167642312000299",
  acknowledgement = ack-nhfb,
  fjournal =     "Science of Computer Programming",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01676423",
}

@Article{Cazzola:2014:JBR,
  author =       "Walter Cazzola and Edoardo Vacchi",
  title =        "{@Java}: Bringing a richer annotation model to
                 {Java}",
  journal =      j-COMP-LANGS-SYS-STRUCT,
  volume =       "40",
  number =       "1",
  pages =        "2--18",
  month =        apr,
  year =         "2014",
  CODEN =        "????",
  ISSN =         "1477-8424 (print), 1873-6866 (electronic)",
  ISSN-L =       "1477-8424",
  bibdate =      "Wed Apr 9 06:43:48 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/complngs.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S1477842414000037",
  acknowledgement = ack-nhfb,
  fjournal =     "Computer Languages, Systems and Structures",
  journal-URL =  "http://www.sciencedirect.com/science/journal/14778424/",
}

@Article{Chong:2014:CCT,
  author =       "Stephen Chong",
  title =        "Checking correctness of {TypeScript} interfaces for
                 {JavaScript} libraries",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "10",
  pages =        "1--16",
  month =        oct,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2714064.2660215",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue May 12 17:41:21 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "The TypeScript programming language adds optional
                 types to JavaScript, with support for interaction with
                 existing JavaScript libraries via interface
                 declarations. Such declarations have been written for
                 hundreds of libraries, but they can be difficult to
                 write and often contain errors, which may affect the
                 type checking and misguide code completion for the
                 application code in IDEs. We present a pragmatic
                 approach to check correctness of TypeScript declaration
                 files with respect to JavaScript library
                 implementations. The key idea in our algorithm is that
                 many declaration errors can be detected by an analysis
                 of the library initialization state combined with a
                 light-weight static analysis of the library function
                 code. Our experimental results demonstrate the
                 effectiveness of the approach: it has found 142 errors
                 in the declaration files of 10 libraries, with an
                 analysis time of a few minutes per library and with a
                 low number of false positives. Our analysis of how
                 programmers use library interface declarations
                 furthermore reveals some practical limitations of the
                 TypeScript type system.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '14 conference proceedings.",
}

@Article{Clifford:2014:AFB,
  author =       "Daniel Clifford and Hannes Payer and Michael
                 Starzinger and Ben L. Titzer",
  title =        "Allocation folding based on dominance",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "11",
  pages =        "15--24",
  month =        nov,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2775049.2602994",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue May 12 17:41:19 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  abstract =     "Memory management system performance is of increasing
                 importance in today's managed languages. Two lingering
                 sources of overhead are the direct costs of memory
                 allocations and write barriers. This paper introduces
                 it allocation folding, an optimization technique where
                 the virtual machine automatically folds multiple memory
                 allocation operations in optimized code together into a
                 single, larger it allocation group. An allocation group
                 comprises multiple objects and requires just a single
                 bounds check in a bump-pointer style allocation, rather
                 than a check for each individual object. More
                 importantly, all objects allocated in a single
                 allocation group are guaranteed to be contiguous after
                 allocation and thus exist in the same generation, which
                 makes it possible to statically remove write barriers
                 for reference stores involving objects in the same
                 allocation group. Unlike object inlining, object
                 fusing, and object colocation, allocation folding
                 requires no special connectivity or ownership relation
                 between the objects in an allocation group. We present
                 our analysis algorithm to determine when it is safe to
                 fold allocations together and discuss our
                 implementation in V8, an open-source, production
                 JavaScript virtual machine. We present performance
                 results for the Octane and Kraken benchmark suites and
                 show that allocation folding is a strong performance
                 improvement, even in the presence of some heap
                 fragmentation. Additionally, we use four hand-selected
                 benchmarks JPEGEncoder, NBody, Soft3D, and Textwriter
                 where allocation folding has a large impact.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "ISMM '14 conference proceedings.",
}

@Article{David:2014:CMC,
  author =       "Florian David and Gael Thomas and Julia Lawall and
                 Gilles Muller",
  title =        "Continuously measuring critical section pressure with
                 the free-lunch profiler",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "10",
  pages =        "291--307",
  month =        oct,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2714064.2660210",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue May 12 17:41:21 MDT 2015",
  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/sigplan2010.bib",
  abstract =     "Today, Java is regularly used to implement large
                 multi-threaded server-class applications that use locks
                 to protect access to shared data. However,
                 understanding the impact of locks on the performance of
                 a system is complex, and thus the use of locks can
                 impede the progress of threads on configurations that
                 were not anticipated by the developer, during specific
                 phases of the execution. In this paper, we propose Free
                 Lunch, a new lock profiler for Java application
                 servers, specifically designed to identify, in-vivo,
                 phases where the progress of the threads is impeded by
                 a lock. Free Lunch is designed around a new metric,
                 critical section pressure (CSP), which directly
                 correlates the progress of the threads to each of the
                 locks. Using Free Lunch, we have identified phases of
                 high CSP, which were hidden with other lock profilers,
                 in the distributed Cassandra NoSQL database and in
                 several applications from the DaCapo 9.12, the
                 SPECjvm2008 and the SPECjbb2005 benchmark suites. Our
                 evaluation of Free Lunch shows that its overhead is
                 never greater than 6\%, making it suitable for in-vivo
                 use.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '14 conference proceedings.",
}

@Article{DeNicola:2014:FAA,
  author =       "Rocco {De Nicola} and Michele Loreti and Rosario
                 Pugliese and Francesco Tiezzi",
  title =        "A Formal Approach to Autonomic Systems Programming:
                 The {SCEL} Language",
  journal =      j-TAAS,
  volume =       "9",
  number =       "2",
  pages =        "7:1--7:??",
  month =        jul,
  year =         "2014",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/2619998",
  ISSN =         "1556-4665 (print), 1556-4703 (electronic)",
  ISSN-L =       "1556-4665",
  bibdate =      "Tue Jul 8 16:04:06 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/taas.bib",
  abstract =     "The autonomic computing paradigm has been proposed to
                 cope with size, complexity, and dynamism of
                 contemporary software-intensive systems. The challenge
                 for language designers is to devise appropriate
                 abstractions and linguistic primitives to deal with the
                 large dimension of systems and with their need to adapt
                 to the changes of the working environment and to the
                 evolving requirements. We propose a set of programming
                 abstractions that permit us to represent behaviors,
                 knowledge, and aggregations according to specific
                 policies and to support programming context-awareness,
                 self-awareness, and adaptation. Based on these
                 abstractions, we define SCEL (Software Component
                 Ensemble Language), a kernel language whose solid
                 semantic foundations lay also the basis for formal
                 reasoning on autonomic systems behavior. To show
                 expressiveness and effectiveness of SCEL;'s design, we
                 present a Java implementation of the proposed
                 abstractions and show how it can be exploited for
                 programming a robotics scenario that is used as a
                 running example for describing the features and
                 potential of our approach.",
  acknowledgement = ack-nhfb,
  articleno =    "7",
  fjournal =     "ACM Transactions on Autonomous and Adaptive Systems
                 (TAAS)",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J1010",
}

@Article{Dissegna:2014:TCA,
  author =       "Stefano Dissegna and Francesco Logozzo and Francesco
                 Ranzato",
  title =        "Tracing compilation by abstract interpretation",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "1",
  pages =        "47--59",
  month =        jan,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2578855.2535866",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Mar 4 17:04:57 MST 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "POPL '14 conference proceedings.",
  abstract =     "Tracing just-in-time compilation is a popular
                 compilation schema 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 the execution of the program
                 to detect so-called hot paths, i.e., the most
                 frequently executed paths. Then, it uses some store
                 information available at runtime to optimize hot paths.
                 The result is a residual program where the optimized
                 hot paths are guarded by sufficient conditions ensuring
                 the equivalence of the optimized path and the original
                 program. The residual program is persistently mutated
                 during its execution, e.g., to add new optimized paths
                 or to merge existing paths. Tracing compilation is thus
                 fundamentally different than traditional static
                 compilation. Nevertheless, despite the remarkable
                 practical success of tracing compilation, very little
                 is known about its theoretical foundations. We
                 formalize tracing compilation of programs using
                 abstract interpretation. The monitoring (viz., hot path
                 detection) phase corresponds to an abstraction of the
                 trace semantics that captures the most frequent
                 occurrences of sequences of program points together
                 with an abstraction of their corresponding stores,
                 e.g., a type environment. The optimization (viz.,
                 residual program generation) phase 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 and to prove them
                 correct. We instantiate it to prove the correctness of
                 dynamic type specialization. We show that our framework
                 is more general than a recent model of tracing
                 compilation introduced in POPL~2011 by Guo and Palsberg
                 (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,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Dyer:2014:DVE,
  author =       "Robert Dyer and Hridesh Rajan and Tien N. Nguyen",
  title =        "Declarative visitors to ease fine-grained source code
                 mining with full history on billions of {AST} nodes",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "3",
  pages =        "23--32",
  month =        mar,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2637365.2517226",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Jun 26 05:58:25 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Software repositories contain a vast wealth of
                 information about software development. Mining these
                 repositories has proven useful for detecting patterns
                 in software development, testing hypotheses for new
                 software engineering approaches, etc. Specifically,
                 mining source code has yielded significant insights
                 into software development artifacts and processes.
                 Unfortunately, mining source code at a large-scale
                 remains a difficult task. Previous approaches had to
                 either limit the scope of the projects studied, limit
                 the scope of the mining task to be more coarse-grained,
                 or sacrifice studying the history of the code due to
                 both human and computational scalability issues. In
                 this paper we address the substantial challenges of
                 mining source code: (a) at a very large scale; (b) at a
                 fine-grained level of detail; and (c) with full history
                 information. To address these challenges, we present
                 domain-specific language features for source code
                 mining. Our language features are inspired by
                 object-oriented visitors and provide a default
                 depth-first traversal strategy along with two
                 expressions for defining custom traversals. We provide
                 an implementation of these features in the Boa
                 infrastructure for software repository mining and
                 describe a code generation strategy into Java code. To
                 show the usability of our domain-specific language
                 features, we reproduced over 40 source code mining
                 tasks from two large-scale previous studies in just 2
                 person-weeks. The resulting code for these tasks show
                 between $ 2.0 \times $--$ 4.8 \times $ reduction in
                 code size. Finally we perform a small controlled
                 experiment to gain insights into how easily mining
                 tasks written using our language features can be
                 understood, with no prior training. We show a
                 substantial number of tasks (77\%) were understood by
                 study participants, in about 3 minutes per task.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "GPCE '13 conference proceedings.",
}

@Article{Eichelberger:2014:FRM,
  author =       "Holger Eichelberger and Klaus Schmid",
  title =        "Flexible resource monitoring of {Java} programs",
  journal =      j-J-SYST-SOFTW,
  volume =       "93",
  number =       "??",
  pages =        "163--186",
  month =        jul,
  year =         "2014",
  CODEN =        "JSSODM",
  ISSN =         "0164-1212 (print), 1873-1228 (electronic)",
  ISSN-L =       "0164-1212",
  bibdate =      "Wed May 21 07:51:51 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/jsystsoftw.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0164121214000533",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Systems and Software",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01641212/",
}

@Article{Erdweg:2014:FEL,
  author =       "Sebastian Erdweg and Felix Rieger",
  title =        "A framework for extensible languages",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "3",
  pages =        "3--12",
  month =        mar,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2637365.2517210",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Jun 26 05:58:25 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Extensible programming languages such as SugarJ or
                 Racket enable programmers to introduce customary
                 language features as extensions of the base language.
                 Traditionally, systems that support language extensions
                 are either (i) agnostic to the base language or (ii)
                 only support a single base language. In this paper, we
                 present a framework for language extensibility that
                 turns a non-extensible language into an extensible
                 language featuring library-based extensible syntax,
                 extensible static analyses, and extensible editor
                 support. To make a language extensible, our framework
                 only requires knowledge of the base language's grammar,
                 the syntax for import statements (which activate
                 extensions), and how to compile base-language programs.
                 We have evaluated the generality of our framework by
                 instantiating it for Java, Haskell, Prolog, JavaScript,
                 and System F$_{ \omega }$, and by studying existing
                 module-system features and their support in our
                 framework.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "GPCE '13 conference proceedings.",
}

@Article{Eslamimehr:2014:RDS,
  author =       "Mahdi Eslamimehr and Jens Palsberg",
  title =        "Race directed scheduling of concurrent programs",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "8",
  pages =        "301--314",
  month =        aug,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2692916.2555263",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Wed Nov 26 16:26:30 MST 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Detection of data races in Java programs remains a
                 difficult problem. The best static techniques produce
                 many false positives, and also the best dynamic
                 techniques leave room for improvement. We present a new
                 technique called race directed scheduling that for a
                 given race candidate searches for an input and a
                 schedule that lead to the race. The search iterates a
                 combination of concolic execution and schedule
                 improvement, and turns out to find useful inputs and
                 schedules efficiently. We use an existing technique to
                 produce a manageable number of race candidates. Our
                 experiments on 23 Java programs found 72 real races
                 that were missed by the best existing dynamic
                 techniques. Among those 72 races, 31 races were found
                 with schedules that have between 1 million and 108
                 million events, which suggests that they are rare and
                 hard-to-find races.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "PPoPP '14 conference proceedings.",
}

@Article{Estevez-Ayres:2014:CSS,
  author =       "Iria Est{\'e}vez-Ayres and Pablo Basanta-Val and
                 Marisol Garc{\'\i}a-Valls",
  title =        "Composing and scheduling service-oriented applications
                 in time-triggered distributed real-time {Java}
                 environments",
  journal =      j-CCPE,
  volume =       "26",
  number =       "1",
  pages =        "152--193",
  month =        jan,
  year =         "2014",
  CODEN =        "CCPEBO",
  DOI =          "https://doi.org/10.1002/cpe.2958",
  ISSN =         "1532-0626 (print), 1532-0634 (electronic)",
  ISSN-L =       "1532-0626",
  bibdate =      "Sat Feb 8 15:45:08 MST 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Concurrency and Computation: Practice and Experience",
  journal-URL =  "http://www.interscience.wiley.com/jpages/1532-0626",
  onlinedate =   "11 Dec 2012",
}

@Article{Fu:2014:FDC,
  author =       "Yupeng Fu and Kian Win Ong and Yannis Papakonstantinou
                 and Erick Zamora",
  title =        "Forward: data-centric {ULS} using declarative
                 templates that efficiently wrap third-party
                 {JavaScript} components",
  journal =      j-PROC-VLDB-ENDOWMENT,
  volume =       "7",
  number =       "13",
  pages =        "1649--1652",
  month =        aug,
  year =         "2014",
  CODEN =        "????",
  ISSN =         "2150-8097",
  bibdate =      "Wed Feb 4 17:20:31 MST 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/vldbe.bib",
  abstract =     "While Ajax programming and the plethora of JavaScript
                 component libraries enable high-quality Uls in web
                 applications, integrating them with page data is
                 laborious and error-prone as a developer has to
                 handcode incremental modifications with trigger-based
                 programming and manual coordination of data
                 dependencies. The FORWARD web framework simplifies the
                 development of Ajax applications through declarative,
                 state-based templates. This declarative, data-centric
                 approach is characterized by the principle of
                 logical/physical independence, which the database
                 community has often deployed successfully. It enables
                 FORWARD to leverage database techniques, such as
                 incremental view maintenance, updatable views,
                 capability-based component wrappers and cost-based
                 optimization to automate efficient live visualizations.
                 We demonstrate an end-to-end system implementation,
                 including a web-based IDE (itself built in FORWARD),
                 academic and commercial applications built in FORWARD
                 and a wide variety of JavaScript components supported
                 by the declarative templates.",
  acknowledgement = ack-nhfb,
  fjournal =     "Proceedings of the VLDB Endowment",
  journal-URL =  "http://portal.acm.org/citation.cfm?id=J1174",
}

@Article{Gerakios:2014:RTP,
  author =       "Prodromos Gerakios and Aggelos Biboudis and Yannis
                 Smaragdakis",
  title =        "Reified type parameters using {Java} annotations",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "3",
  pages =        "61--64",
  month =        mar,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2637365.2517223",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Jun 26 05:58:25 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Java generics are compiled by-erasure: all clients
                 reuse the same bytecode, with uses of the unknown type
                 erased. C++ templates are compiled by-expansion: each
                 type-instantiation of a template produces a different
                 code definition. The two approaches offer trade-offs on
                 multiple axes. We propose an extension of Java generics
                 that allows by-expansion translation relative to
                 selected type parameters only. This language design
                 allows sophisticated users to get the best of both
                 worlds at a fine granularity. Furthermore, our proposal
                 is based on Java 8 Type Annotations (JSR 308) and the
                 Checker Framework as an abstraction layer for
                 controlling compilation without changes to the
                 internals of a Java compiler.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "GPCE '13 conference proceedings.",
}

@Article{Golan-Gueta:2014:ASL,
  author =       "Guy Golan-Gueta and G. Ramalingam and Mooly Sagiv and
                 Eran Yahav",
  title =        "Automatic semantic locking",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "8",
  pages =        "385--386",
  month =        aug,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2692916.2555281",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Wed Nov 26 16:26:30 MST 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "In this paper, we consider concurrent programs in
                 which the shared state consists of instances of
                 linearizable ADTs (abstract data types). We develop a
                 novel automated approach to concurrency control that
                 addresses a common need: the need to atomically execute
                 a code fragment, which may contain multiple ADT
                 operations on multiple ADT instances. In our approach,
                 each ADT implements ADT-specific semantic locking
                 operations that serve to exploit the semantics of ADT
                 operations. We develop a synthesis algorithm that
                 automatically inserts calls to these locking operations
                 in a set of given code fragments (in a client program)
                 to ensure that these code fragments execute atomically
                 without deadlocks, and without rollbacks. We have
                 implemented the synthesis algorithm and several
                 general-purpose ADTs with semantic locking. We have
                 applied the synthesis algorithm to several Java
                 programs that use these ADTs. Our results show that our
                 approach enables efficient and scalable
                 synchronization.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "PPoPP '14 conference proceedings.",
}

@Book{Gosling:2014:JLS,
  author =       "James Gosling and Bill Joy and Guy L. {Steele Jr.} and
                 Gilad Bracha and Alex Buckley",
  title =        "The {Java} Language Specification",
  publisher =    pub-AW,
  address =      pub-AW,
  edition =      "{Java SE 8}",
  pages =        "xxii + 758",
  year =         "2014",
  ISBN =         "0-13-390069-X (paperback)",
  ISBN-13 =      "978-0-13-390069-9 (paperback)",
  LCCN =         "QA76.73.J38 G68 2014",
  bibdate =      "Sat Dec 17 13:05:12 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/mathcw.bib;
                 z3950.loc.gov:7090/Voyager",
  abstract =     "Written by the inventors of the technology,
                 \booktitle{The Java Language Specification, Java SE 8
                 Edition} is the definitive technical reference for the
                 Java programming language. The book provides complete,
                 accurate, and detailed coverage of the Java programming
                 language. It fully describes the new features added in
                 Java SE 8, including lambda expressions, method
                 references, default methods, type annotations, and
                 repeating annotations. The book also includes many
                 explanatory notes and carefully distinguishes the
                 formal rules of the language from the practical
                 behavior of compilers.",
  acknowledgement = ack-nhfb,
  author-dates = "1955--",
  subject =      "Java (Computer program language)",
  tableofcontents = "Introduction \\
                 Grammars \\
                 Lexical Structure \\
                 Types, Values, and Variables \\
                 Conversions and Contexts \\
                 Names \\
                 Packages \\
                 Classes \\
                 Interfaces \\
                 Arrays \\
                 Exceptions \\
                 Execution \\
                 Binary Compatibility \\
                 Blocks and Statements \\
                 Expressions \\
                 Definite Assignment \\
                 Threads and Locks \\
                 Type Inference \\
                 Syntax",
}

@Article{Greenman:2014:GFB,
  author =       "Ben Greenman and Fabian Muehlboeck and Ross Tate",
  title =        "Getting {F}-bounded polymorphism into shape",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "6",
  pages =        "89--99",
  month =        jun,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2666356.2594308",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Sep 26 07:38:28 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "We present a way to restrict recursive inheritance
                 without sacrificing the benefits of F-bounded
                 polymorphism. In particular, we distinguish two new
                 concepts, materials and shapes, and demonstrate through
                 a survey of 13.5 million lines of open-source
                 generic-Java code that these two concepts never
                 actually overlap in practice. With this Material-Shape
                 Separation, we prove that even na{\"\i}ve type-checking
                 algorithms are sound and complete, some of which
                 address problems that were unsolvable even under the
                 existing proposals for restricting inheritance. We
                 illustrate how the simplicity of our design reflects
                 the design intuitions employed by programmers and
                 potentially enables new features coming into demand for
                 upcoming programming languages.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  received =     "PLDI '14 conference proceedings.",
}

@Article{Gunther:2014:ACC,
  author =       "John C. Gunther",
  title =        "{Algorithm 938}: Compressing circular buffers",
  journal =      j-TOMS,
  volume =       "40",
  number =       "2",
  pages =        "17:1--17:12",
  month =        feb,
  year =         "2014",
  CODEN =        "ACMSCU",
  DOI =          "https://doi.org/10.1145/2559995",
  ISSN =         "0098-3500 (print), 1557-7295 (electronic)",
  ISSN-L =       "0098-3500",
  bibdate =      "Fri Mar 14 06:30:41 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/toms.bib",
  abstract =     "Data sequences generated by on-line sensors can become
                 arbitrarily large and must, therefore, be pared down to
                 fit into available memory. For situations where only
                 the most recent data is of interest, this problem can
                 be solved with optimal efficiency by a simple circular
                 buffer: it fills each memory location with useful data,
                 and requires just one write to memory per update. The
                 algorithm presented here provides essentially the same
                 efficiency, but while maintaining a continuously
                 updated, fixed-size, compressed representation of the
                 entire data sequence. Each value in these compressed
                 sequences represents a statistic (an average, maximum,
                 random sample, etc.) computed over a contiguous chunk
                 of the original sequence. Compressing circular buffers
                 gain their efficiency by using an alternative indexing
                 sequence, based on well-known principles of elementary
                 number theory, to ensure that each newly written value
                 gets stored in the unoccupied location created when the
                 two oldest sequential over-sampled values are
                 compressed into one. The associated Java implementation
                 supports a variety of aggregating statistics and is
                 used to compare the algorithm's performance with a more
                 obvious approach (doubling).",
  acknowledgement = ack-nhfb,
  articleno =    "17",
  fjournal =     "ACM Transactions on Mathematical Software (TOMS)",
  journal-URL =  "http://dl.acm.org/pub.cfm?id=J782",
}

@Article{Guyer:2014:UJT,
  author =       "Samuel Z. Guyer",
  title =        "Use of the {JVM} at {Twitter}: a bird's eye view",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "11",
  pages =        "1--1",
  month =        nov,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2775049.2619208",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue May 12 17:41:19 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  abstract =     "Specialties: 15+ years of virtual machine
                 implementation experience with special focus on memory
                 management / garbage collection. Close to 20 years of
                 C/C++ experience. 15+ years of Java experience. Expert
                 in concurrent/parallel programming.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "ISMM '14 conference proceedings.",
}

@Article{Haubl:2014:TTE,
  author =       "Christian H{\"a}ubl and Christian Wimmer and Hanspeter
                 M{\"o}ssenb{\"o}ck",
  title =        "Trace transitioning and exception handling in a
                 trace-based {JIT} compiler for {Java}",
  journal =      j-TACO,
  volume =       "11",
  number =       "1",
  pages =        "6:1--6:??",
  month =        feb,
  year =         "2014",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/2579673",
  ISSN =         "1544-3566 (print), 1544-3973 (electronic)",
  ISSN-L =       "1544-3566",
  bibdate =      "Fri Mar 14 17:30:52 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/taco.bib",
  abstract =     "Trace-based Just-In-Time (JIT) compilation generates
                 machine code for frequently executed paths (so-called
                 traces) instead of whole methods. While this has
                 several advantages, it complicates invocation of
                 compiled traces as well as exception handling, so that
                 previous trace-based compilers limited the way in which
                 traces could be invoked. We present a significantly
                 enhanced trace-based compiler where arbitrary
                 transitions between interpreted and compiled traces are
                 possible. For that, we introduce suitable trace calling
                 conventions and extend exception handling to work both
                 within traces and across trace boundaries. Furthermore,
                 we use the recorded trace information for optimizations
                 and combine the tracing ideas with ideas from
                 partial-method compilation to avoid code bloat. An
                 extensive evaluation with the benchmark suites DaCapo
                 9.12 Bach and SPECjvm2008 shows that our trace-based
                 compiler achieves up to 59\% higher peak performance
                 than the method-based Java HotSpot client compiler. On
                 a few benchmarks, our fairly simple trace-based
                 compiler shows a higher peak performance than the Java
                 HotSpot server compiler, which is one of today's best
                 optimizing JIT compilers for Java.",
  acknowledgement = ack-nhfb,
  articleno =    "6",
  fjournal =     "ACM Transactions on Architecture and Code Optimization
                 (TACO)",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J924",
}

@Article{Higuera-Toledano:2014:EIS,
  author =       "M. Teresa Higuera-Toledano and Andy Wellings",
  title =        "Editorials: Introduction to the {Special Issue on Java
                 Technologies for Real-Time and Embedded Systems: JTRES
                 2012}",
  journal =      j-CCPE,
  volume =       "26",
  number =       "14",
  pages =        "2405--2406",
  day =          "25",
  month =        sep,
  year =         "2014",
  CODEN =        "CCPEBO",
  DOI =          "https://doi.org/10.1002/cpe.3310",
  ISSN =         "1532-0626 (print), 1532-0634 (electronic)",
  ISSN-L =       "1532-0626",
  bibdate =      "Wed Feb 11 22:34:10 MST 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Concurrency and Computation: Practice and Experience",
  journal-URL =  "http://www.interscience.wiley.com/jpages/1532-0626",
  onlinedate =   "19 Jun 2014",
}

@Article{Hlopko:2014:ISJ,
  author =       "Marcel Hlopko and Jan Kurs and Jan Vran{\'y} and Claus
                 Gittinger",
  title =        "On the integration of {Smalltalk} and {Java}",
  journal =      j-SCI-COMPUT-PROGRAM,
  volume =       "96 (part 1)",
  number =       "??",
  pages =        "17--33",
  day =          "15",
  month =        dec,
  year =         "2014",
  CODEN =        "SCPGD4",
  ISSN =         "0167-6423 (print), 1872-7964 (electronic)",
  ISSN-L =       "0167-6423",
  bibdate =      "Tue Oct 21 18:32:39 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/scicomputprogram.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0167642313002839",
  acknowledgement = ack-nhfb,
  fjournal =     "Science of Computer Programming",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01676423/",
}

@Article{Horie:2014:SDJ,
  author =       "Michihiro Horie and Kazunori Ogata and Kiyokuni
                 Kawachiya and Tamiya Onodera",
  title =        "String deduplication for {Java}-based middleware in
                 virtualized environments",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "7",
  pages =        "177--188",
  month =        jul,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2674025.2576210",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Sep 26 07:29:50 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "To increase the memory efficiency in physical servers
                 is a significant concern for increasing the number of
                 virtual machines (VM) in them. When similar web
                 application service runs in each guest VM, many string
                 data with the same values are created in every guest
                 VMs. These duplications of string data are redundant
                 from the viewpoint of memory efficiency in the host OS.
                 This paper proposes two approaches to reduce the
                 duplication in Java string in a single Java VM (JVM)
                 and across JVMs. The first approach is to share string
                 objects cross JVMs by using a read-only memory-mapped
                 file. The other approach is to selectively unify string
                 objects created at runtime in the web applications.
                 This paper evaluates our approach by using the Apache
                 DayTrader and the DaCapo benchmark suite. Our prototype
                 implementation achieved 7\% to 12\% reduction in the
                 total size of the objects allocated over the lifetime
                 of the programs. In addition, we observed the
                 performance of DayTrader was maintained even under a
                 situation of high density guest VMs in a KVM host
                 machine.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "VEE '14 conference proceedings.",
}

@Article{Hower:2014:HRF,
  author =       "Derek R. Hower and Blake A. Hechtman and Bradford M.
                 Beckmann and Benedict R. Gaster and Mark D. Hill and
                 Steven K. Reinhardt and David A. Wood",
  title =        "Heterogeneous-race-free memory models",
  journal =      j-COMP-ARCH-NEWS,
  volume =       "42",
  number =       "1",
  pages =        "427--440",
  month =        mar,
  year =         "2014",
  CODEN =        "CANED2",
  DOI =          "https://doi.org/10.1145/2654822.2541981",
  ISSN =         "0163-5964 (print), 1943-5851 (electronic)",
  ISSN-L =       "0163-5964",
  bibdate =      "Mon Aug 18 17:12:47 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigarch.bib",
  abstract =     "Commodity heterogeneous systems (e.g., integrated CPUs
                 and GPUs), now support a unified, shared memory address
                 space for all components. Because the latency of global
                 communication in a heterogeneous system can be
                 prohibitively high, heterogeneous systems (unlike
                 homogeneous CPU systems) provide synchronization
                 mechanisms that only guarantee ordering among a subset
                 of threads, which we call a scope. Unfortunately, the
                 consequences and semantics of these scoped operations
                 are not yet well under-stood. Without a formal and
                 approachable model to reason about the behavior of
                 these operations, we risk an array of portability and
                 performance issues. In this paper, we embrace scoped
                 synchronization with a new class of memory consistency
                 models that add scoped synchronization to
                 data-race-free models like those of C++ and Java.
                 Called sequential consistency for
                 heterogeneous-race-free (SC for HRF), the new models
                 guarantee SC for programs with ``sufficient''
                 synchronization (no data races) of ``sufficient''
                 scope. We discuss two such models. The first,
                 HRF-direct, works well for programs with highly regular
                 parallelism. The second, HRF-indirect, builds on
                 HRF-direct by allowing synchronization using different
                 scopes in some cases involving transitive
                 communication. We quantitatively show that HRF-indirect
                 encourages forward-looking programs with irregular
                 parallelism by showing up to a 10\% performance
                 increase in a task runtime for GPUs.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGARCH Computer Architecture News",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J89",
  remark =       "ASPLOS '14 conference proceedings.",
}

@Article{Hsiao:2014:UWC,
  author =       "Chun-Hung Hsiao and Michael Cafarella and Satish
                 Narayanasamy",
  title =        "Using web corpus statistics for program analysis",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "10",
  pages =        "49--65",
  month =        oct,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2714064.2660226",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue May 12 17:41:21 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Several program analysis tools --- such as plagiarism
                 detection and bug finding --- rely on knowing a piece
                 of code's relative semantic importance. For example, a
                 plagiarism detector should not bother reporting two
                 programs that have an identical simple loop counter
                 test, but should report programs that share more
                 distinctive code. Traditional program analysis
                 techniques ( e.g., finding data and control
                 dependencies) are useful, but do not say how surprising
                 or common a line of code is. Natural language
                 processing researchers have encountered a similar
                 problem and addressed it using an n -gram model of text
                 frequency, derived from statistics computed over text
                 corpora. We propose and compute an n -gram model for
                 programming languages, computed over a corpus of 2.8
                 million JavaScript programs we downloaded from the Web.
                 In contrast to previous techniques, we describe a code
                 n -gram as a subgraph of the program dependence graph
                 that contains all nodes and edges reachable in n steps
                 from the statement. We can count n -grams in a program
                 and count the frequency of n -grams in the corpus,
                 enabling us to compute tf-idf -style measures that
                 capture the differing importance of different lines of
                 code. We demonstrate the power of this approach by
                 implementing a plagiarism detector with accuracy that
                 beats previous techniques, and a bug-finding tool that
                 discovered over a dozen previously unknown bugs in a
                 collection of real deployed programs.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '14 conference proceedings.",
}

@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-SIGPLAN,
  volume =       "49",
  number =       "6",
  pages =        "27--27",
  month =        jun,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2666356.2594346",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Sep 26 07:38:28 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.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. In
                 this environment, the interactions between application
                 threads and the language runtime (e.g., the garbage
                 collector) are regulated by compiler-injected code
                 snippets. Example of snippets include allocation fast
                 paths among others. In our TOPLAS paper 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,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  received =     "PLDI '14 conference proceedings.",
}

@Article{Jung:2014:HCO,
  author =       "Dong-Heon Jung and Soo-Mook Moon and Hyeong-Seok Oh",
  title =        "Hybrid compilation and optimization for {Java}-based
                 digital {TV} platforms",
  journal =      j-TECS,
  volume =       "13",
  number =       "2s",
  pages =        "62:1--62:??",
  month =        jan,
  year =         "2014",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/2506257",
  ISSN =         "1539-9087 (print), 1558-3465 (electronic)",
  ISSN-L =       "1539-9087",
  bibdate =      "Tue Jan 28 17:34:43 MST 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/tecs.bib",
  abstract =     "The Java-based software platform for interactive
                 digital TV (DTV) is composed of the system/middleware
                 class statically installed on the DTV set-top box and
                 the xlet applications dynamically downloaded from the
                 TV stations. The xlet application includes Java classes
                 and image/text files. The xlets are executed only when
                 the TV viewer initiates an interaction, even if the
                 xlets have been completely downloaded. To achieve high
                 performance on this dual-component, user-initiated
                 system, existing just-in-time (JIT) compilation and
                 optimization is not enough; instead, ahead-of-time and
                 idle-time compilation and optimization are also needed,
                 requiring a hybrid compilation and optimization
                 environment. We constructed such a hybrid environment
                 for a commercial DTV software platform and evaluated it
                 using real, on-air xlet applications. Our experimental
                 results show that the proposed hybrid environment can
                 improve the DTV Java performance by more than three
                 times, compared to the JIT-only environment, with
                 little change to other DTV behavior.",
  acknowledgement = ack-nhfb,
  articleno =    "62",
  fjournal =     "ACM Transactions on Embedded Computing Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?&idx=J840",
}

@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,
  articleno =    "14",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Kalibera:2014:FAS,
  author =       "Tomas Kalibera and Petr Maj and Floreal Morandat and
                 Jan Vitek",
  title =        "A fast abstract syntax tree interpreter for {R}",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "7",
  pages =        "89--102",
  month =        jul,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2674025.2576205",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Sep 26 07:29:50 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/s-plus.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Dynamic languages have been gaining popularity to the
                 point that their performance is starting to matter. The
                 effort required to develop a production-quality,
                 high-performance runtime is, however, staggering and
                 the expertise required to do so is often out of reach
                 of the community maintaining a particular language.
                 Many domain specific languages remain stuck with naive
                 implementations, as they are easy to write and simple
                 to maintain for domain scientists. In this paper, we
                 try to see how far one can push a naive implementation
                 while remaining portable and not requiring expertise in
                 compilers and runtime systems. We choose the R
                 language, a dynamic language used in statistics, as the
                 target of our experiment and adopt the simplest
                 possible implementation strategy, one based on
                 evaluation of abstract syntax trees. We build our
                 interpreter on top of a Java virtual machine and use
                 only facilities available to all Java programmers. We
                 compare our results to other implementations of R.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "VEE '14 conference proceedings.",
}

@Article{Kashyap:2014:TRS,
  author =       "Vineeth Kashyap and John Sarracino and John Wagner and
                 Ben Wiedermann and Ben Hardekopf",
  title =        "Type refinement for static analysis of {JavaScript}",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "2",
  pages =        "17--26",
  month =        feb,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2578856.2508175",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Mar 4 17:05:03 MST 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "DLS '13 conference proceedings.",
  abstract =     "Static analysis of JavaScript has proven useful for a
                 variety of purposes, including optimization, error
                 checking, security auditing, program refactoring, and
                 more. We propose a technique called type refinement
                 that can improve the precision of such static analyses
                 for JavaScript without any discernible performance
                 impact. Refinement is a known technique that uses the
                 conditions in branch guards to refine the analysis
                 information propagated along each branch path. The key
                 insight of this paper is to recognize that JavaScript
                 semantics include many implicit conditional checks on
                 types, and that performing type refinement on these
                 implicit checks provides significant benefit for
                 analysis precision. To demonstrate the effectiveness of
                 type refinement, we implement a static analysis tool
                 for reporting potential type-errors in JavaScript
                 programs. We provide an extensive empirical evaluation
                 of type refinement using a benchmark suite containing a
                 variety of JavaScript application domains, ranging from
                 the standard performance benchmark suites (Sunspider
                 and Octane), to open-source JavaScript applications, to
                 machine-generated JavaScript via Emscripten. We show
                 that type refinement can significantly improve analysis
                 precision by up to 86\% without affecting the
                 performance of the analysis.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Kedlaya:2014:DDL,
  author =       "Madhukar N. Kedlaya and Behnam Robatmili and Cglin
                 Cascaval and Ben Hardekopf",
  title =        "Deoptimization for dynamic language {JITs} on typed,
                 stack-based virtual machines",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "7",
  pages =        "103--114",
  month =        jul,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2674025.2576209",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Sep 26 07:29:50 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "We are interested in implementing dynamic language
                 runtimes on top of language-level virtual machines.
                 Type specialization is a critical optimization for
                 dynamic language runtimes: generic code that handles
                 any type of data is replaced with specialized code for
                 particular types observed during execution. However,
                 types can change, and the runtime must recover whenever
                 unexpected types are encountered. The state-of-the-art
                 recovery mechanism is called deoptimization.
                 Deoptimization is a well-known technique for dynamic
                 language runtimes implemented in low-level languages
                 like C. However, no dynamic language runtime
                 implemented on top of a virtual machine such as the
                 Common Language Runtime (CLR) or the Java Virtual
                 Machine (JVM) uses deoptimization, because the
                 implementation thereof used in low-level languages is
                 not possible. In this paper we propose a novel
                 technique that enables deoptimization for dynamic
                 language runtimes implemented on top of typed,
                 stack-based virtual machines. Our technique does not
                 require any changes to the underlying virtual machine.
                 We implement our proposed technique in a JavaScript
                 language implementation, MCJS, running on top of the
                 Mono runtime (CLR). We evaluate our implementation
                 against the current state-of-the-art recovery mechanism
                 for virtual machine-based runtimes, as implemented both
                 in MCJS and in IronJS. We show that deoptimization
                 provides significant performance benefits, even for
                 runtimes running on top of a virtual machine.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "VEE '14 conference proceedings.",
}

@Article{Kedlaya:2014:ITS,
  author =       "Madhukar N. Kedlaya and Jared Roesch and Behnam
                 Robatmili and Mehrdad Reshadi and Ben Hardekopf",
  title =        "Improved type specialization for dynamic scripting
                 languages",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "2",
  pages =        "37--48",
  month =        feb,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2578856.2508177",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Mar 4 17:05:03 MST 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "DLS '13 conference proceedings.",
  abstract =     "Type feedback and type inference are two common
                 methods used to optimize dynamic languages such as
                 JavaScript. Each of these methods has its own strengths
                 and weaknesses, and we propose that each can benefit
                 from the other if combined in the right way. We explore
                 the interdependency between these two methods and
                 propose two novel ways to combine them in order to
                 significantly increase their aggregate benefit and
                 decrease their aggregate overhead. In our proposed
                 strategy, an initial type inference pass is applied
                 that can reduce type feedback overhead by enabling more
                 intelligent placement of profiling hooks. This initial
                 type inference pass is novel in the literature. After
                 profiling, a final type inference pass uses the type
                 information from profiling to generate efficient code.
                 While this second pass is not novel, we significantly
                 improve its effectiveness in a novel way by feeding the
                 type inference pass information about the function
                 signature, i.e., the types of the function's arguments
                 for a specific function invocation. Our results show
                 significant speedups when using these low-overhead
                 strategies, ranging from $ 1.2 \times $ to $ 4 \times $
                 over an implementation that does not perform type
                 feedback or type inference based optimizations. Our
                 experiments are carried out across a wide range of
                 traditional benchmarks and realistic web applications.
                 The results also show an average reduction of 23.5\% in
                 the size of the profiled data for these benchmarks.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Keil:2014:EDA,
  author =       "Matthias Keil and Peter Thiemann",
  title =        "Efficient dynamic access analysis using {JavaScript}
                 proxies",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "2",
  pages =        "49--60",
  month =        feb,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2578856.2508176",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Mar 4 17:05:03 MST 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "DLS '13 conference proceedings.",
  abstract =     "JSConTest introduced the notions of effect monitoring
                 and dynamic effect inference for JavaScript. It enables
                 the description of effects with path specifications
                 resembling regular expressions. It is implemented by an
                 offline source code transformation. To overcome the
                 limitations of the JSConTest implementation, we
                 redesigned and reimplemented effect monitoring by
                 taking advantage of JavaScript proxies. Our new design
                 avoids all drawbacks of the prior implementation. It
                 guarantees full interposition; it is not restricted to
                 a subset of JavaScript; it is self-maintaining; and its
                 scalability to large programs is significantly better
                 than with JSConTest. The improved scalability has two
                 sources. First, the reimplementation is significantly
                 faster than the original, transformation-based
                 implementation. Second, the reimplementation relies on
                 the fly-weight pattern and on trace reduction to
                 conserve memory. Only the combination of these
                 techniques enables monitoring and inference for large
                 programs.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Kersten:2014:RRA,
  author =       "Rody W. J. Kersten and Bernard E. van Gastel and Olha
                 Shkaravska and Manuel Montenegro and Marko C. J. D. van
                 Eekelen",
  title =        "{ResAna}: a resource analysis toolset for (real-time)
                 {JAVA}",
  journal =      j-CCPE,
  volume =       "26",
  number =       "14",
  pages =        "2432--2455",
  day =          "25",
  month =        sep,
  year =         "2014",
  CODEN =        "CCPEBO",
  DOI =          "https://doi.org/10.1002/cpe.3154",
  ISSN =         "1532-0626 (print), 1532-0634 (electronic)",
  ISSN-L =       "1532-0626",
  bibdate =      "Wed Feb 11 22:34:10 MST 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Concurrency and Computation: Practice and Experience",
  journal-URL =  "http://www.interscience.wiley.com/jpages/1532-0626",
  onlinedate =   "8 Oct 2013",
}

@Article{Kim:2014:LBL,
  author =       "Hongjune Kim and Seonmyeong Bak and Jaejin Lee",
  title =        "Lightweight and block-level concurrent sweeping for
                 {JavaScript} garbage collection",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "5",
  pages =        "155--164",
  month =        may,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2666357.2597824",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Sep 26 07:37:30 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "JavaScript is a dynamic-typed language originally
                 developed for the purpose of giving dynamic client-side
                 behaviors to web pages. It is mainly used in web
                 application development and because of its popularity
                 and rapid development style it is now also used in
                 other types of applications. Increasing data processing
                 requirements and growing usage in more resource-limited
                 environments, such as mobile devices, has given demands
                 for JavaScript implementations to handle memory more
                 efficiently through garbage collection. Since
                 aggressive use of time consuming operations in garbage
                 collection can slow down the JavaScript application,
                 there is a trade-off relationship between the
                 effectiveness and the execution time of garbage
                 collection. In this paper, we present a lightweight,
                 block-level concurrent sweeping mechanism for a
                 mark-and-sweep garbage collector. The sweeping process
                 is detached to an additional thread to eagerly collect
                 free memory blocks and recycle it. To minimize the
                 overhead that comes from the synchronization between
                 the mutator thread and the new sweeping thread, we have
                 chosen a course grained block-level collecting scheme
                 for sweeping. To avoid contention that comes from
                 object destruction, we execute the object destruction
                 phase concurrently with the foreground marking phase.
                 We have implemented our algorithm in JavaScript Core
                 (JSC) engine embedded in the WebKit browser that uses a
                 variant of mark-and-sweep algorithm to manage
                 JavaScript objects. The original garbage collection
                 implementation performs lazy sweeping that cannot reuse
                 the free blocks. We evaluate our implementation on an
                 ARM-based mobile system and show that memory
                 utilization of the system is significantly improved
                 without performance degradation.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "LCTES '14 conference proceedings.",
}

@Article{Kolesnikov:2014:CPB,
  author =       "Sergiy Kolesnikov and Alexander von Rhein and Claus
                 Hunsen and Sven Apel",
  title =        "A comparison of product-based, feature-based, and
                 family-based type checking",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "3",
  pages =        "115--124",
  month =        mar,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2637365.2517213",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Jun 26 05:58:25 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Analyzing software product lines is difficult, due to
                 their inherent variability. In the past, several
                 strategies for product-line analysis have been
                 proposed, in particular, product-based, feature-based,
                 and family-based strategies. Despite recent attempts to
                 conceptually and empirically compare different
                 strategies, there is no work that empirically compares
                 all of the three strategies in a controlled setting. We
                 close this gap by extending a compiler for
                 feature-oriented programming with support for
                 product-based, feature-based, and family-based type
                 checking. We present and discuss the results of a
                 comparative performance evaluation that we conducted on
                 a set of 12 feature-oriented, Java-based product lines.
                 Most notably, we found that the family-based strategy
                 is superior for all subject product lines: it is
                 substantially faster, it detects all kinds of errors,
                 and provides the most detailed information about
                 them.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "GPCE '13 conference proceedings.",
}

@Article{Korsholm:2014:RTJ,
  author =       "Stephan E. Korsholm and Hans S{\o}ndergaard and Anders
                 P. Ravn",
  title =        "A real-time {Java} tool chain for resource constrained
                 platforms",
  journal =      j-CCPE,
  volume =       "26",
  number =       "14",
  pages =        "2407--2431",
  day =          "25",
  month =        sep,
  year =         "2014",
  CODEN =        "CCPEBO",
  DOI =          "https://doi.org/10.1002/cpe.3164",
  ISSN =         "1532-0626 (print), 1532-0634 (electronic)",
  ISSN-L =       "1532-0626",
  bibdate =      "Wed Feb 11 22:34:10 MST 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Concurrency and Computation: Practice and Experience",
  journal-URL =  "http://www.interscience.wiley.com/jpages/1532-0626",
  onlinedate =   "17 Oct 2013",
}

@Article{Krebs:2014:JJB,
  author =       "Nico Krebs and Lothar Schmitz",
  title =        "{Jaccie}: a {Java}-based compiler-compiler for
                 generating, visualizing and debugging compiler
                 components",
  journal =      j-SCI-COMPUT-PROGRAM,
  volume =       "79",
  number =       "??",
  pages =        "101--115",
  day =          "1",
  month =        jan,
  year =         "2014",
  CODEN =        "SCPGD4",
  ISSN =         "0167-6423 (print), 1872-7964 (electronic)",
  ISSN-L =       "0167-6423",
  bibdate =      "Sat Nov 30 15:06:12 MST 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/scicomputprogram.bib;
                 http://www.sciencedirect.com/science/journal/01676423",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0167642312000469",
  acknowledgement = ack-nhfb,
  fjournal =     "Science of Computer Programming",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01676423",
}

@Article{Lerner:2014:TRT,
  author =       "Benjamin S. Lerner and Joe Gibbs Politz and Arjun Guha
                 and Shriram Krishnamurthi",
  title =        "{TeJaS}: retrofitting type systems for {JavaScript}",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "2",
  pages =        "1--16",
  month =        feb,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2578856.2508170",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Mar 4 17:05:03 MST 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "DLS '13 conference proceedings.",
  abstract =     "JavaScript programs vary widely in functionality,
                 complexity, and use, and analyses of these programs
                 must accommodate such variations. Type-based analyses
                 are typically the simplest such analyses, but due to
                 the language's subtle idioms and many
                 application-specific needs --- such as ensuring
                 general-purpose type correctness, security properties,
                 or proper library usage --- we have found that a single
                 type system does not suffice for all purposes. However,
                 these varied uses still share many reusable common
                 elements. In this paper we present TeJaS, a framework
                 for building type systems for JavaScript. TeJaS has
                 been engineered modularly to encourage experimentation.
                 Its initial type environment is reified, to admit easy
                 modeling of the various execution contexts of
                 JavaScript programs, and its type language and typing
                 rules are extensible, to enable variations of the type
                 system to be constructed easily. The paper presents the
                 base TeJaS type system, which performs traditional
                 type-checking for JavaScript. Because JavaScript
                 demands complex types, we explain several design
                 decisions to improve user ergonomics. We then describe
                 TeJaS's modular structure, and illustrate it by
                 reconstructing the essence of a very different type
                 system for JavaScript. Systems built from TeJaS have
                 been applied to several real-world, third-party
                 JavaScript programs.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Li:2014:EAJ,
  author =       "Siliang Li and Gang Tan",
  title =        "Exception analysis in the {Java Native Interface}",
  journal =      j-SCI-COMPUT-PROGRAM,
  volume =       "89 (part C)",
  number =       "??",
  pages =        "273--297",
  day =          "1",
  month =        sep,
  year =         "2014",
  CODEN =        "SCPGD4",
  ISSN =         "0167-6423 (print), 1872-7964 (electronic)",
  ISSN-L =       "0167-6423",
  bibdate =      "Fri May 9 18:22:29 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/scicomputprogram.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0167642314000446",
  acknowledgement = ack-nhfb,
  fjournal =     "Science of Computer Programming",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01676423/",
}

@Article{Li:2014:MHD,
  author =       "Pengcheng Li and Chen Ding and Hao Luo",
  title =        "Modeling heap data growth using average liveness",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "11",
  pages =        "71--82",
  month =        nov,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2775049.2602997",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue May 12 17:41:19 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  abstract =     "Most of today's programs make use of a sizable heap to
                 store dynamic data. To characterize the heap dynamics,
                 this paper presents a set of metrics to measure the
                 average amount of data live and dead in a period of
                 execution. They are collectively called average
                 liveness. The paper defines these metrics of average
                 liveness, gives linear-time algorithms for measurement,
                 and discusses their use in finding the best heap size.
                 The algorithms are implemented in a Java tracing system
                 called Elephant Tracks and evaluated using the Dacapo
                 benchmarks running on the Oracle HotSpot and IBM J9
                 Java virtual machines.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "ISMM '14 conference proceedings.",
}

@Book{Lindholm:2014:JVM,
  author =       "Tim Lindholm and Frank Yellin and Gilad Bracha and
                 Alex Buckley",
  title =        "The {Java} Virtual Machine Specification: {Java SE 8}
                 edition",
  publisher =    pub-AW,
  address =      pub-AW,
  pages =        "xvi + 584",
  year =         "2014",
  ISBN =         "0-13-390590-X (paperback), 0-13-392274-X (e-book)",
  ISBN-13 =      "978-0-13-390590-8 (paperback), 978-0-13-392274-5
                 (e-book)",
  LCCN =         "QA76.73.J38 L56 2014",
  bibdate =      "Thu Dec 4 07:34:57 MST 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/mathcw.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib;
                 z3950.loc.gov:7090/Voyager",
  abstract =     "Written by the inventors of the technology, this is
                 the definitive technical reference for the Java Virtual
                 Machine. The book provides complete, accurate, and
                 detailed coverage of the Java Virtual Machine. It fully
                 describes the new features added in Java SE 8,
                 including the invocation of default methods and the
                 class file extensions for type annotations and method
                 parameters. The book also clarifies the interpretation
                 of class file attributes and the rules of bytecode
                 verification.",
  acknowledgement = ack-nhfb,
  subject =      "Java (Computer program language)",
  tableofcontents = "1 Introduction / 1 \\
                 1.1 A Bit of History / 1 \\
                 1.2 The Java Virtual Machine / 2 \\
                 1.3 Organization of the Specification / 3 \\
                 1.4 Notation / 4 \\
                 1.5 Feedback / 4 \\
                 \\
                 2 The Structure of the Java Virtual Machine / 5 \\
                 2.1 The class File Format / 5 \\
                 2.2 Data Types / 6 \\
                 2.3 Primitive Types and Values / 6 \\
                 2.3.1 Integral Types and Values / 7 \\
                 2.3.2 Floating-Point Types, Value Sets, and Values / 8
                 \\
                 2.3.3 The returnAddress Type and Values / 10 \\
                 2.3.4 The boolean Type / 10 \\
                 2.4 Reference Types and Values / 11 \\
                 2.5 Run-Time Data Areas / 11 \\
                 2.5.1 The pc Register / 12 \\
                 2.5.2 Java Virtual Machine Stacks / 12 \\
                 2.5.3 Heap / 13 \\
                 2.5.4 Method Area / 13 \\
                 2.5.5 Run-Time Constant Pool / 14 \\
                 2.5.6 Native Method Stacks / 14 \\
                 2.6 Frames / 15 \\
                 2.6.1 Local Variables / 16 \\
                 2.6.2 Operand Stacks / 17 \\
                 2.6.3 Dynamic Linking / 18 \\
                 2.6.4 Normal Method Invocation Completion / 18 \\
                 2.6.5 Abrupt Method Invocation Completion / 18 \\
                 2.7 Representation of Objects / 19 \\
                 2.8 Floating-Point Arithmetic / 19 \\
                 2.8.1 Java Virtual Machine Floating-Point Arithmetic
                 and IEEE 754 / 19 \\
                 2.8.2 Floating-Point Modes / 20 \\
                 2.8.3 Value Set Conversion / 20 \\
                 2.9 Special Methods / 22 \\
                 2.10 Exceptions / 23 \\
                 2.11 Instruction Set Summary / 25 \\
                 2.11.1 Types and the Java Virtual Machine / 26 \\
                 2.11.2 Load and Store Instructions / 29 \\
                 2.11.3 Arithmetic Instructions / 30 \\
                 2.11.4 Type Conversion Instructions / 32 \\
                 2.11.5 Object Creation and Manipulation / 34 \\
                 2.11.6 Operand Stack Management Instructions / 34 \\
                 2.11.7 Control Transfer Instructions / 34 \\
                 2.11.8 Method Invocation and Return Instructions / 35
                 \\
                 2.11.9 Throwing Exceptions / 36 \\
                 2.11.10 Synchronization / 36 \\
                 2.12 Class Libraries / 37 \\
                 2.13 Public Design, Private Implementation / 37 \\
                 \\
                 3 Compiling for the Java Virtual Machine / 39 \\
                 3.1 Format of Examples / 39 \\
                 3.2 Use of Constants, Local Variables, and Control
                 Constructs / 40 \\
                 3.3 Arithmetic / 45 \\
                 3.4 Accessing the Run-Time Constant Pool / 46 \\
                 3.5 More Control Examples / 47 \\
                 3.6 Receiving Arguments / 50 \\
                 3.7 Invoking Methods / 51 \\
                 3.8 Working with Class Instances / 53 \\
                 3.9 Arrays / 55 \\
                 3.10 Compiling Switches / 57 \\
                 3.11 Operations on the Operand Stack / 59 \\
                 3.12 Throwing and Handling Exceptions / 60 \\
                 3.13 Compiling finally / 63 \\
                 3.14 Synchronization / 66 \\
                 3.15 Annotations / 67 \\
                 \\
                 4 The class File Format / 69 \\
                 4.1 The ClassFile Structure / 70 \\
                 4.2 The Internal Form of Names / 74 \\
                 4.2.1 Binary Class and Interface Names / 74 \\
                 4.2.2 Unqualified Names / 75 \\
                 4.3 Descriptors / 75 \\
                 4.3.1 Grammar Notation / 75 \\
                 4.3.2 Field Descriptors / 76 \\
                 4.3.3 Method Descriptors / 77 \\
                 4.4 The Constant Pool / 78 \\
                 4.4.1 The CONSTANT_Class_info Structure / 79 \\
                 4.4.2 The CONSTANT_Fieldref_info,
                 CONSTANT_Methodref_info, and
                 CONSTANT_InterfaceMethodref_info Structures / 80 \\
                 4.4.3 The CONSTANT_String_info Structure / 81 \\
                 4.4.4 The CONSTANT_Integer_info and CONSTANT_Float_info
                 Structures / 82 \\
                 4.4.5 The CONSTANT_Long_info and CONSTANT_Double_info
                 Structures / 83 \\
                 4.4.6 The CONSTANT_NameAndType_info Structure / 85 \\
                 4.4.7 The CONSTANT_Utf8_info Structure / 85 \\
                 4.4.8 The CONSTANT_MethodHandle_info Structure / 87 \\
                 4.4.9 The CONSTANT_MethodType_info Structure / 89 \\
                 4.4.10 The CONSTANT_InvokeDynamic_info Structure / 89
                 \\
                 4.5 Fields / 90 \\
                 4.6 Methods / 92 \\
                 4.7 Attributes / 95 \\
                 4.7.1 Defining and Naming New Attributes / 101 \\
                 4.7.2 The ConstantValue Attribute / 101 \\
                 4.7.3 The Code Attribute / 102 \\
                 4.7.4 The StackMapTable Attribute / 106 \\
                 4.7.5 The Exceptions Attribute / 113 \\
                 4.7.6 The InnerClasses Attribute / 114 \\
                 4.7.7 The EnclosingMethod Attribute / 116 \\
                 4.7.8 The Synthetic Attribute / 118 \\
                 4.7.9 The Signature Attribute / 118 \\
                 4.7.9.1 Signatures / 119 \\
                 4.7.10 The SourceFile Attribute / 123 \\
                 4.7.11 The SourceDebugExtension Attribute / 124 \\
                 4.7.12 The LineNumberTable Attribute / 124 \\
                 4.7.13 The LocalVariableTable Attribute / 126 \\
                 4.7.14 The LocalVariableTypeTable Attribute / 128 \\
                 4.7.15 The Deprecated Attribute / 129 \\
                 4.7.16 The RuntimeVisibleAnnotations Attribute / 130
                 \\
                 4.7.16.1 The element_value structure / 132 \\
                 4.7.17 The RuntimeInvisibleAnnotations Attribute / 135
                 \\
                 4.7.18 The RuntimeVisibleParameterAnnotations Attribute
                 / 136 \\
                 4.7.19 The RuntimeInvisibleParameterAnnotations
                 Attribute / 137 \\
                 4.7.20 The RuntimeVisibleTypeAnnotations Attribute /
                 139 \\
                 4.7.20.1 The target_info union / 144 \\
                 4.7.20.2 The type_path structure / 148 \\
                 4.7.21 The RuntimeInvisibleTypeAnnotations Attribute /
                 152 \\
                 4.7.22 The AnnotationDefault Attribute / 153 \\
                 4.7.23 The BootstrapMethods Attribute / 154 \\
                 4.7.24 The MethodParameters Attribute / 156 \\
                 4.8 Format Checking / 158 \\
                 4.9 Constraints on Java Virtual Machine Code / 159 \\
                 4.9.1 Static Constraints / 159 \\
                 4.9.2 Structural Constraints / 163 \\
                 4.10 Verification of class Files / 166 \\
                 4.10.1 Verification by Type Checking / 167 \\
                 4.10.1.1 Accessors for Java Virtual Machine Artifacts /
                 169 \\
                 4.10.1.2 Verification Type System / 173 \\
                 4.10.1.3 Instruction Representation / 177 \\
                 4.10.1.4 Stack Map Frame Representation / 178 \\
                 4.10.1.5 Type Checking Abstract and Native Methods /
                 184 \\
                 4.10.1.6 Type Checking Methods with Code / 187 \\
                 4.10.1.7 Type Checking Load and Store Instructions /
                 194 \\
                 4.10.1.8 Type Checking for protected Members / 196 \\
                 4.10.1.9 Type Checking Instructions / 199 \\
                 4.10.2 Verification by Type Inference / 319 \\
                 4.10.2.1 The Process of Verification by Type Inference
                 / 319 \\
                 4.10.2.2 The Bytecode Verifier / 319 \\
                 4.10.2.3 Values of Types long and double / 323 \\
                 4.10.2.4 Instance Initialization Methods and Newly
                 Created Objects / 323 \\
                 4.10.2.5 Exceptions and finally / 325 \\
                 4.11 Limitations of the Java Virtual Machine / 327 \\
                 \\
                 5 Loading, Linking, and Initializing / 329 \\
                 5.1 The Run-Time Constant Pool / 329 \\
                 5.2 Java Virtual Machine Startup / 332 \\
                 5.3 Creation and Loading / 332 \\
                 5.3.1 Loading Using the Bootstrap Class Loader / 334
                 \\
                 5.3.2 Loading Using a User-defined Class Loader / 335
                 \\
                 5.3.3 Creating Array Classes / 336 \\
                 5.3.4 Loading Constraints / 336 \\
                 5.3.5 Deriving a Class from a class File Representation
                 / 338 \\
                 5.4 Linking / 339 \\
                 5.4.1 Verification / 340 \\
                 5.4.2 Preparation / 340 \\
                 5.4.3 Resolution / 341 \\
                 5.4.3.1 Class and Interface Resolution / 342 \\
                 5.4.3.2 Field Resolution / 343 \\
                 5.4.3.3 Method Resolution / 344 \\
                 5.4.3.4 Interface Method Resolution / 346 \\
                 5.4.3.5 Method Type and Method Handle Resolution / 347
                 \\
                 5.4.3.6 Call Site Specifier Resolution / 350 \\
                 5.4.4 Access Control / 351 \\
                 5.4.5 Overriding / 352 \\
                 5.5 Initialization / 352 \\
                 5.6 Binding Native Method Implementations / 355 \\
                 5.7 Java Virtual Machine Exit / 355 \\
                 \\
                 6 The Java Virtual Machine Instruction Set / 357 \\
                 6.1 Assumptions: The Meaning of ``Must'' / 357 \\
                 6.2 Reserved Opcodes / 358 \\
                 6.3 Virtual Machine Errors / 358 \\
                 6.4 Format of Instruction Descriptions / 359 \\
                 mnemonic / 360 \\
                 6.5 Instructions / 362 \\
                 aaload / 363 \\
                 aastore / 364 \\
                 aconst_null / 366 \\
                 aload / 367 \\
                 aload_<n> / 368 \\
                 anewarray / 369 \\
                 areturn / 370 \\
                 arraylength / 371 \\
                 astore / 372 \\
                 astore_<n> / 373 \\
                 athrow / 374 \\
                 baload / 376 \\
                 bastore / 377 \\
                 bipush / 378 \\
                 caload / 379 \\
                 castore / 380 \\
                 checkcast / 381 \\
                 d2f / 383 \\
                 d2i / 384 \\
                 d2l / 385 \\
                 dadd / 386 \\
                 daload / 388 \\
                 dastore / 389 \\
                 dcmp<op> / 390 \\
                 dconst_<d> / 392 \\
                 ddiv / 393 \\
                 dload / 395 \\
                 dload_<n> / 396 \\
                 dmul / 397 \\
                 dneg / 399 \\
                 drem / 400 \\
                 dreturn / 402 \\
                 dstore / 403 \\
                 dstore_<n> / 404 \\
                 dsub / 405 \\
                 dup / 406 \\
                 dup_x1 / 407 \\
                 dup_x2 / 408 \\
                 dup2 / 409 \\
                 dup2_x1 / 410 \\
                 dup2_x2 / 411 \\
                 f2d / 413 \\
                 f2i / 414 \\
                 f2l / 415 \\
                 fadd / 416 \\
                 faload / 418 \\
                 fastore / 419 \\
                 fcmp<op> / 420 \\
                 fconst_<f> / 422 \\
                 fdiv / 423 \\
                 fload / 425 \\
                 fload_<n> / 426 \\
                 fmul / 427 \\
                 fneg / 429 \\
                 frem / 430 \\
                 freturn / 432 \\
                 fstore / 433 \\
                 fstore_<n> / 434 \\
                 fsub / 435 \\
                 getfield / 436 \\
                 getstatic / 438 \\
                 goto / 440 \\
                 goto_w / 441 \\
                 i2b / 442 \\
                 i2c / 443 \\
                 i2d / 444 \\
                 i2f / 445 \\
                 i2l / 446 \\
                 i2s / 447 \\
                 iadd / 448 \\
                 iaload / 449 \\
                 iand / 450 \\
                 iastore / 451 \\
                 iconst_<i> / 452 \\
                 idiv / 453 \\
                 if_acmp<cond> / 454 \\
                 if_icmp<cond> / 455 \\
                 if<cond> / 457 \\
                 ifnonnull / 459 \\
                 ifnull / 460 \\
                 iinc / 461 \\
                 iload / 462 \\
                 iload_<n> / 463 \\
                 imul / 464 \\
                 ineg / 465 \\
                 instanceof / 466 \\
                 invokedynamic / 468 \\
                 invokeinterface / 473 \\
                 invokespecial / 477 \\
                 invokestatic / 481 \\
                 invokevirtual / 484 \\
                 ior / 489 \\
                 irem / 490 \\
                 ireturn / 491 \\
                 ishl / 492 \\
                 ishr / 493 \\
                 istore / 494 \\
                 istore_<n> / 495 \\
                 isub / 496 \\
                 iushr / 497 \\
                 ixor / 498 \\
                 jsr / 499 \\
                 jsr_w / 500 \\
                 l2d / 501 \\
                 l2f / 502 \\
                 l2i / 503 \\
                 ladd / 504 \\
                 laload / 505 \\
                 land / 506 \\
                 lastore / 507 \\
                 lcmp / 508 \\
                 lconst_<l> / 509 \\
                 ldc / 510 \\
                 ldc_w / 512 \\
                 ldc2_w / 514 \\
                 ldiv / 515 \\
                 lload / 516 \\
                 lload_<n> / 517 \\
                 lmul / 518 \\
                 lneg / 519 \\
                 lookupswitch / 520 \\
                 lor / 522 \\
                 lrem / 523 \\
                 lreturn / 524 \\
                 lshl / 525 \\
                 lshr / 526 \\
                 lstore / 527 \\
                 lstore_<n> / 528 \\
                 lsub / 529 \\
                 lushr / 530 \\
                 lxor / 531 \\
                 monitorenter / 532 \\
                 monitorexit / 534 \\
                 multianewarray / 536 \\
                 new / 538 \\
                 newarray / 540 \\
                 nop / 542 \\
                 pop / 543 \\
                 pop2 / 544 \\
                 putfield / 545 \\
                 putstatic / 547 \\
                 ret / 549 \\
                 return / 550 \\
                 saload / 551 \\
                 sastore / 552 \\
                 sipush / 553 \\
                 swap / 554 \\
                 tableswitch / 555 \\
                 wide / 557 \\
                 \\
                 7 Opcode Mnemonics by Opcode / 559 \\
                 Index / 563 \\
                 \\
                 A Limited License Grant / 581",
}

@Article{Liu:2014:FFL,
  author =       "Peng Liu and Omer Tripp and Xiangyu Zhang",
  title =        "{Flint}: fixing linearizability violations",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "10",
  pages =        "543--560",
  month =        oct,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2714064.2660217",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue May 12 17:41:21 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Writing concurrent software while achieving both
                 correctness and efficiency is a grand challenge. To
                 facilitate this task, concurrent data structures have
                 been introduced into the standard library of popular
                 languages like Java and C\#. Unfortunately, while the
                 operations exposed by concurrent data structures are
                 atomic (or linearizable), compositions of these
                 operations are not necessarily atomic. Recent studies
                 have found many erroneous implementations of composed
                 concurrent operations. We address the problem of fixing
                 nonlinearizable composed operations such that they
                 behave atomically. We introduce Flint, an automated
                 fixing algorithm for composed Map operations. Flint
                 accepts as input a composed operation suffering from
                 atomicity violations. Its output, if fixing succeeds,
                 is a composed operation that behaves equivalently to
                 the original operation in sequential runs and is
                 guaranteed to be atomic. To our knowledge, Flint is the
                 first general algorithm for fixing incorrect concurrent
                 compositions. We have evaluated Flint on 48 incorrect
                 compositions from 27 popular applications, including
                 Tomcat and MyFaces. The results are highly encouraging:
                 Flint is able to correct 96\% of the methods, and the
                 fixed version is often the same as the fix by an expert
                 programmer and as efficient as the original code.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '14 conference proceedings.",
}

@Article{Liu:2014:JNU,
  author =       "Alex Liu",
  title =        "{JavaScript} and the {Netflix} User Interface",
  journal =      j-QUEUE,
  volume =       "12",
  number =       "9",
  pages =        "20",
  month =        sep,
  year =         "2014",
  CODEN =        "AQCUAE",
  DOI =          "https://doi.org/10.1145/2674600.2677720",
  ISSN =         "1542-7730 (print), 1542-7749 (electronic)",
  ISSN-L =       "1542-7730",
  bibdate =      "Mon Oct 20 18:06:48 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/queue.bib",
  abstract =     "Conditional dependency resolution",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM Queue: Tomorrow's Computing Today",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?&idx=J882",
}

@Article{Luu:2014:MCC,
  author =       "Loi Luu and Shweta Shinde and Prateek Saxena and Brian
                 Demsky",
  title =        "A model counter for constraints over unbounded
                 strings",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "6",
  pages =        "565--576",
  month =        jun,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2666356.2594331",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Sep 26 07:38:28 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Model counting is the problem of determining the
                 number of solutions that satisfy a given set of
                 constraints. Model counting has numerous applications
                 in the quantitative analyses of program execution time,
                 information flow, combinatorial circuit designs as well
                 as probabilistic reasoning. We present a new approach
                 to model counting for structured data types,
                 specifically strings in this work. The key ingredient
                 is a new technique that leverages generating functions
                 as a basic primitive for combinatorial counting. Our
                 tool SMC which embodies this approach can model count
                 for constraints specified in an expressive string
                 language efficiently and precisely, thereby
                 outperforming previous finite-size analysis tools. SMC
                 is expressive enough to model constraints arising in
                 real-world JavaScript applications and UNIX C
                 utilities. We demonstrate the practical feasibility of
                 performing quantitative analyses arising in security
                 applications, such as determining the comparative
                 strengths of password strength meters and determining
                 the information leakage via side channels.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  received =     "PLDI '14 conference proceedings.",
}

@Article{Marek:2014:SRC,
  author =       "Luk{\'a}s Marek and Stephen Kell and Yudi Zheng and
                 Lubom{\'\i}r Bulej and Walter Binder and Petr Tuma and
                 Danilo Ansaloni and Aibek Sarimbekov and Andreas Sewe",
  title =        "{ShadowVM}: robust and comprehensive dynamic program
                 analysis for the {Java} platform",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "3",
  pages =        "105--114",
  month =        mar,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2637365.2517219",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Jun 26 05:58:25 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Dynamic analysis tools are often implemented using
                 instrumentation, particularly on managed runtimes
                 including the Java Virtual Machine (JVM). Performing
                 instrumentation robustly is especially complex on such
                 runtimes: existing frameworks offer limited coverage
                 and poor isolation, while previous work has shown that
                 apparently innocuous instrumentation can cause
                 deadlocks or crashes in the observed application. This
                 paper describes ShadowVM, a system for
                 instrumentation-based dynamic analyses on the JVM which
                 combines a number of techniques to greatly improve both
                 isolation and coverage. These centre on the offload of
                 analysis to a separate process; we believe our design
                 is the first system to enable genuinely full bytecode
                 coverage on the JVM. We describe a working
                 implementation, and use a case study to demonstrate its
                 improved coverage and to evaluate its runtime
                 overhead.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "GPCE '13 conference proceedings.",
}

@Article{Martin:2014:TCR,
  author =       "Marko Martin and Mira Mezini and Sebastian Erdweg",
  title =        "Template constructors for reusable object
                 initialization",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "3",
  pages =        "43--52",
  month =        mar,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2637365.2517212",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Jun 26 05:58:25 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Reuse of and abstraction over object initialization
                 logic is not properly supported in mainstream
                 object-oriented languages. This may result in
                 significant amount of boilerplate code and
                 proliferation of constructors in subclasses. It also
                 makes it impossible for mixins to extend the
                 initialization interface of classes they are applied
                 to. We propose template constructors, which employ
                 template parameters and pattern matching of them
                 against signatures of superclass constructors to enable
                 a one-to-many binding of super-calls. We demonstrate
                 how template constructors solve the aforementioned
                 problems. We present a formalization of the concept, a
                 Java-based implementation, and use cases which exercise
                 its strengths.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "GPCE '13 conference proceedings.",
}

@Article{Martinsen:2014:HTL,
  author =       "Jan Kasper Martinsen and Hakan Grahn and Anders
                 Isberg",
  title =        "Heuristics for Thread-Level Speculation in {Web}
                 Applications",
  journal =      j-IEEE-COMPUT-ARCHIT-LETT,
  volume =       "13",
  number =       "2",
  pages =        "77--80",
  month =        jul # "\slash " # dec,
  year =         "2014",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1109/L-CA.2013.26",
  ISSN =         "1556-6056 (print), 1556-6064 (electronic)",
  ISSN-L =       "1556-6056",
  bibdate =      "Thu Jun 20 17:18:18 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ieeecomputarchitlett.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "JavaScript is a sequential programming language, and
                 Thread-Level Speculation has been proposed to
                 dynamically extract parallelism in order to take
                 advantage of parallel hardware. In previous work, we
                 have showed significant speed-ups with a simple on/off
                 speculation heuristic. In this paper, we propose and
                 evaluate three heuristics for dynamically adapt the
                 speculation: a 2-bit heuristic, an exponential
                 heuristic, and a combination of these two. Our results
                 show that the combined heuristic is able to both
                 increase the number of successful speculations and
                 decrease the execution time for 15 popular web
                 applications.",
  acknowledgement = ack-nhfb,
  affiliation =  "Martinsen, JK (Reprint Author), Blekinge Inst Technol,
                 Sch Comp, SE-37179 Karlskrona, Sweden. Martinsen, Jan
                 Kasper; Grahn, Hakan, Blekinge Inst Technol, Sch Comp,
                 SE-37179 Karlskrona, Sweden. Isberg, Anders, Sony
                 Mobile Commun AB, SE-22188 Lund, Sweden.",
  author-email = "Jan.Kasper.Martinsen@bth.se Hakan.Grahn@bth.se
                 Anders.Isberg@sonymobile.com",
  da =           "2019-06-20",
  doc-delivery-number = "AX5PM",
  eissn =        "1556-6064",
  fjournal =     "IEEE Computer Architecture Letters",
  funding-acknowledgement = "Industrial Excellence Center EASE -
                 Embedded Applications Software Engineering; BESQ+
                 research project --- Knowledge Foundation in Sweden
                 [20100311]",
  funding-text = "This work was partly funded by the Industrial
                 Excellence Center EASE --- Embedded Applications
                 Software Engineering, (http://ease.cs.lth.se), and the
                 BESQ+ research project funded by the Knowledge
                 Foundation (grant number 20100311) in Sweden.",
  journal-iso =  "IEEE Comput. Archit. Lett.",
  journal-URL =  "http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=10208",
  keywords =     "Automatic Parallelization; JavaScript; Multicore
                 processors; Parallel Computing",
  number-of-cited-references = "12",
  oa =           "Green Published",
  ORCID-numbers = "Martinsen, Jan Kasper/0000-0001-8915-3633 Grahn,
                 Hakan/0000-0001-9947-1088",
  research-areas = "Computer Science",
  times-cited =  "2",
  unique-id =    "Martinsen:2014:HTL",
  web-of-science-categories = "Computer Science, Hardware \&
                 Architecture",
}

@Article{Meijer:2014:EJR,
  author =       "Erik Meijer",
  title =        "Evolution of {Javascript} Revisited",
  journal =      j-QUEUE,
  volume =       "12",
  number =       "2",
  pages =        "50",
  month =        feb,
  year =         "2014",
  CODEN =        "AQCUAE",
  DOI =          "https://doi.org/10.1145/2578508.2594349",
  ISSN =         "1542-7730 (print), 1542-7749 (electronic)",
  ISSN-L =       "1542-7730",
  bibdate =      "Wed May 21 11:03:43 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/queue.bib",
  abstract =     "One of the highlights from Node Summit 2013, remixed.
                 Moderated by: Erik Meijer, Founder, Applied Duality
                 https://vimeo.com/nodesummit/review/85785879/7844ffa516",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM Queue: Tomorrow's Computing Today",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?&idx=J882",
}

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

@Article{Murawski:2014:GSI,
  author =       "Andrzej S. Murawski and Nikos Tzevelekos",
  title =        "Game semantics for interface middleweight {Java}",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "1",
  pages =        "517--528",
  month =        jan,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2578855.2535880",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Mar 4 17:04:57 MST 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "POPL '14 conference proceedings.",
  abstract =     "We consider an object calculus in which open terms
                 interact with the environment through interfaces. The
                 calculus is intended to capture the essence of
                 contextual interactions of Middleweight Java code.
                 Using game semantics, we provide fully abstract models
                 for the induced notions of contextual approximation and
                 equivalence. These are the first denotational models of
                 this kind.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Book{Nolan:2014:XWT,
  author =       "Deborah Ann Nolan and Duncan Temple Lang",
  title =        "{XML} and {Web} technologies for data sciences with
                 {R}",
  publisher =    pub-SV,
  address =      pub-SV:adr,
  pages =        "xxiv + 663",
  year =         "2014",
  ISBN =         "1-4614-7899-5",
  ISBN-13 =      "978-1-4614-7899-7",
  LCCN =         "QA76.76.H94 N65 2014",
  bibdate =      "Wed Feb 11 10:57:20 MST 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/s-plus.bib;
                 z3950.loc.gov:7090/Voyager",
  series =       "Use R!",
  URL =          "http://www.loc.gov/catdir/enhancements/fy1503/2013954669-b.html;
                 http://www.loc.gov/catdir/enhancements/fy1503/2013954669-d.html;
                 http://www.loc.gov/catdir/enhancements/fy1503/2013954669-t.html",
  abstract =     "Web technologies are increasingly relevant to
                 scientists working with data, for both accessing data
                 and creating rich dynamic and interactive displays. The
                 XML and JSON data formats are widely used in Web
                 services, regular Web pages and JavaScript code, and
                 visualization formats such as SVG and KML for Google
                 Earth and Google Maps. In addition, scientists use HTTP
                 and other network protocols to scrape data from Web
                 pages, access REST and SOAP Web Services, and interact
                 with NoSQL databases and text search applications. This
                 book provides a practical hands-on introduction to
                 these technologies, including high-level functions the
                 authors have developed for data scientists. It
                 describes strategies and approaches for extracting data
                 from HTML, XML, and JSON formats and how to
                 programmatically access data from the Web. Along with
                 these general skills, the authors illustrate several
                 applications that are relevant to data scientists, such
                 as reading and writing spreadsheet documents both
                 locally and via GoogleDocs, creating interactive and
                 dynamic visualizations, displaying spatial-temporal
                 displays with Google Earth, and generating code from
                 descriptions of data structures to read and write data.
                 These topics demonstrate the rich possibilities and
                 opportunities to do new things with these modern
                 technologies. The book contains many examples and
                 case-studies that readers can use directly and adapt to
                 their own work.",
  acknowledgement = ack-nhfb,
  subject =      "XML (Document markup language); R (Computer program
                 language); Web services; Electronic data processing",
  tableofcontents = "Data Formats XML and JSON \\
                 Web Technologies, Getting Data from the Web \\
                 General XML Application Areas \\
                 Bibliography \\
                 General Index \\
                 R Function and Parameter Index \\
                 R Package Index \\
                 R Class Index \\
                 Colophon",
}

@Book{Oaks:2014:JPD,
  author =       "Scott Oaks",
  title =        "{Java} Performance: The Definitive Guide",
  publisher =    pub-ORA-MEDIA,
  address =      pub-ORA-MEDIA:adr,
  pages =        "xiv + 408",
  year =         "2014",
  ISBN =         "1-4493-5845-4 (paperback), 1-4493-6354-7 (e-book)",
  ISBN-13 =      "978-1-4493-5845-7 (paperback), 978-1-4493-6354-3
                 (e-book)",
  LCCN =         "QA76.73.J38",
  bibdate =      "Thu Dec 4 13:14:48 MST 2014",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/ora.bib",
  URL =          "http://proquest.safaribooksonline.com/9781449363512",
  abstract =     "Coding and testing are often considered separate areas
                 of expertise. In this comprehensive guide, author and
                 Java expert Scott Oaks takes the approach that anyone
                 who works with Java should be equally adept at
                 understanding how code behaves in the JVM, as well as
                 the tunings likely to help its performance. You'll gain
                 in-depth knowledge of Java application performance,
                 using the Java Virtual Machine (JVM) and the Java
                 platform, including the language and API. Developers
                 and performance engineers alike will learn a variety of
                 features, tools, and processes for improving the way
                 Java 7 and 8 applications perform. Apply four
                 principles for obtaining the best results from
                 performance testing Use JDK tools to collect data on
                 how a Java application is performing Understand the
                 advantages and disadvantages of using a JIT compiler
                 Tune JVM garbage collectors to affect programs as
                 little as possible Use techniques to manage heap memory
                 and JVM native memory Maximize Java threading and
                 synchronization performance features Tackle performance
                 issues in Java EE and Java SE APIs Improve Java-driven
                 database application performance.",
  acknowledgement = ack-nhfb,
  subject =      "Java (Computer program language)",
}

@Article{Ortin:2014:RPI,
  author =       "Francisco Ortin and Patricia Conde and Daniel
                 Fernandez-Lanvin and Raul Izquierdo",
  title =        "The Runtime Performance of {{\tt invokedynamic}}: An
                 Evaluation with a {Java} Library",
  journal =      j-IEEE-SOFTWARE,
  volume =       "31",
  number =       "4",
  pages =        "82--90",
  month =        jul # "\slash " # aug,
  year =         "2014",
  CODEN =        "IESOEG",
  DOI =          "https://doi.org/10.1109/MS.2013.46",
  ISSN =         "0740-7459 (print), 1937-4194 (electronic)",
  ISSN-L =       "0740-7459",
  bibdate =      "Mon Aug 25 07:50:47 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ieeesoft.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE Software",
  journal-URL =  "http://www.computer.org/portal/web/csdl/magazines/software",
}

@Article{Papadimitriou:2014:MLS,
  author =       "Stergios Papadimitriou and Seferina Mavroudi and
                 Kostas Theofilatos and Spiridon Likothanasis",
  title =        "{MATLAB}-like scripting of {Java} scientific libraries
                 in {ScalaLab}",
  journal =      j-SCI-PROG,
  volume =       "22",
  number =       "3",
  pages =        "187--199",
  month =        "????",
  year =         "2014",
  CODEN =        "SCIPEV",
  DOI =          "https://doi.org/10.3233/SPR-140378",
  ISSN =         "1058-9244 (print), 1875-919X (electronic)",
  ISSN-L =       "1058-9244",
  bibdate =      "Tue Sep 9 18:01:15 MDT 2014",
  bibsource =    "http://www.iospress.nl/;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/matlab.bib;
                 https://www.math.utah.edu/pub/tex/bib/sciprog.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Scientific Programming",
  journal-URL =  "http://iospress.metapress.com/content/1058-9244",
}

@Book{Pape:2014:EJV,
  author =       "Tobias Pape and Arian Treffer and Robert Hirschfeld
                 and Michael Haupt",
  title =        "Extending a {Java Virtual Machine} to Dynamic
                 Object-oriented Languages",
  volume =       "82",
  publisher =    "Universit{\"a}tsverlag Potsdam",
  address =      "Potsdam, Germany",
  pages =        "163",
  year =         "2014",
  ISBN =         "3-86956-266-8",
  ISBN-13 =      "978-3-86956-266-7",
  LCCN =         "????",
  bibdate =      "Thu Dec 4 08:01:22 MST 2014",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  series =       "Technische Berichte des Hasso-Plattner-Instituts
                 f{\"u}r Softwaresystemtechnik an der Universit{\"a}t
                 Potsdam",
  URL =          "http://d-nb.info/1046379119/04;
                 http://opus.kobv.de/ubp/volltexte/2013/6743/",
  acknowledgement = ack-nhfb,
  subject =      "Java Virtual Machine; Objektorientierte
                 Programmiersprache; Dynamische Optimierung",
}

@Article{Park:2014:AAS,
  author =       "Changhee Park and Hongki Lee and Sukyoung Ryu",
  title =        "All about the with statement in {JavaScript}: removing
                 with statements in {JavaScript} applications",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "2",
  pages =        "73--84",
  month =        feb,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2578856.2508173",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Mar 4 17:05:03 MST 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "DLS '13 conference proceedings.",
  abstract =     "The with statement in JavaScript makes static analysis
                 of JavaScript applications difficult by introducing a
                 new scope at run time and thus invalidating lexical
                 scoping. Therefore, many static approaches to
                 JavaScript program analysis and the strict mode of
                 ECMAScript 5 simply disallow the with statement. To
                 justify exclusion of the with statement, we should
                 better understand the actual usage patterns of the with
                 statement. In this paper, we present the usage patterns
                 of the with statement in real-world JavaScript
                 applications currently used in the 898 most popular web
                 sites. We investigate whether we can rewrite the with
                 statements in each pattern to other statements not
                 using the with statement. We show that we can rewrite
                 all the static occurrences of the with statement that
                 do not have any dynamic code generating functions. Even
                 though the rewriting process is not applicable to any
                 dynamically generated with statements, our results are
                 still promising. Because all the static approaches that
                 disallow the with statement also disallow dynamic code
                 generation, such static approaches can allow the with
                 statement using our rewriting process. We formally
                 present our rewriting strategy, provide its
                 implementation, and show its faithfulness using
                 extensive testing. We believe that removing with
                 statements will simplify JavaScript program analysis
                 designs without considering dynamic scope introduction
                 while imposing fewer syntactic restrictions.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Paul:2014:RTP,
  author =       "Anand Paul",
  title =        "Real-Time Power Management for Embedded {M2M} Using
                 Intelligent Learning Methods",
  journal =      j-TECS,
  volume =       "13",
  number =       "5s",
  pages =        "148:1--148:??",
  month =        sep,
  year =         "2014",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/2632158",
  ISSN =         "1539-9087 (print), 1558-3465 (electronic)",
  ISSN-L =       "1539-9087",
  bibdate =      "Mon Oct 6 16:07:59 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/tecs.bib",
  abstract =     "In this work, an embedded system working model is
                 designed with one server that receives requests by a
                 requester by a service queue that is monitored by a
                 Power Manager (PM). A novel approach is presented based
                 on reinforcement learning to predict the best policy
                 amidst existing DPM policies and deterministic
                 Markovian nonstationary policies (DMNSP). We apply
                 reinforcement learning, namely a computational approach
                 to understanding and automating goal-directed learning
                 that supports different devices according to their DPM.
                 Reinforcement learning uses a formal framework defining
                 the interaction between agent and environment in terms
                 of states, response action, and reward points. The
                 capability of this approach is demonstrated by an
                 event-driven simulator designed using Java with a
                 power-manageable machine-to-machine device. Our
                 experiment result shows that the proposed dynamic power
                 management with timeout policy gives average power
                 saving from 4\% to 21\% and the novel dynamic power
                 management with DMNSP gives average power saving from
                 10\% to 28\% more than already proposed DPM policies.",
  acknowledgement = ack-nhfb,
  articleno =    "148",
  fjournal =     "ACM Transactions on Embedded Computing Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?&idx=J840",
}

@Article{Pina:2014:RDJ,
  author =       "Lu{\'\i}s Pina and Lu{\'\i}s Veiga and Michael Hicks",
  title =        "{Rubah}: {DSU} for {Java} on a stock {JVM}",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "10",
  pages =        "103--119",
  month =        oct,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2714064.2660220",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue May 12 17:41:21 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "This paper presents Rubah, the first dynamic software
                 updating system for Java that: is portable, implemented
                 via libraries and bytecode rewriting on top of a
                 standard JVM; is efficient, imposing essentially no
                 overhead on normal, steady-state execution; is
                 flexible, allowing nearly arbitrary changes to classes
                 between updates; and is non-disruptive, employing
                 either a novel eager algorithm that transforms the
                 program state with multiple threads, or a novel lazy
                 algorithm that transforms objects as they are demanded,
                 post-update. Requiring little programmer effort, Rubah
                 has been used to dynamically update five long-running
                 applications: the H2 database, the Voldemort key-value
                 store, the Jake2 implementation of the Quake 2 shooter
                 game, the CrossFTP server, and the JavaEmailServer.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '14 conference proceedings.",
}

@Article{Pinto:2014:UEB,
  author =       "Gustavo Pinto and Fernando Castor and Yu David Liu",
  title =        "Understanding energy behaviors of thread management
                 constructs",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "10",
  pages =        "345--360",
  month =        oct,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2714064.2660235",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue May 12 17:41:21 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Java programmers are faced with numerous choices in
                 managing concurrent execution on multicore platforms.
                 These choices often have different trade-offs (e.g.,
                 performance, scalability, and correctness guarantees).
                 This paper analyzes an additional dimension, energy
                 consumption. It presents an empirical study aiming to
                 illuminate the relationship between the choices and
                 settings of thread management constructs and energy
                 consumption. We consider three important thread
                 management constructs in concurrent programming:
                 explicit thread creation, fixed-size thread pooling,
                 and work stealing. We further shed light on the
                 energy/performance trade-off of three ``tuning knobs''
                 of these constructs: the number of threads, the task
                 division strategy, and the characteristics of processed
                 data. Through an extensive experimental space
                 exploration over real-world Java programs, we produce a
                 list of findings about the energy behaviors of
                 concurrent programs, which are not always obvious. The
                 study serves as a first step toward improving energy
                 efficiency of concurrent programs on parallel
                 architectures.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '14 conference proceedings.",
}

@Article{Pradel:2014:EAR,
  author =       "Michael Pradel and Parker Schuh and George Necula and
                 Koushik Sen",
  title =        "{EventBreak}: analyzing the responsiveness of user
                 interfaces through performance-guided test generation",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "10",
  pages =        "33--47",
  month =        oct,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2714064.2660233",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue May 12 17:41:21 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Event-driven user interface applications typically
                 have a single thread of execution that processes event
                 handlers in response to input events triggered by the
                 user, the network, or other applications. Programmers
                 must ensure that event handlers terminate after a short
                 amount of time because otherwise, the application may
                 become unresponsive. This paper presents EventBreak, a
                 performance-guided test generation technique to
                 identify and analyze event handlers whose execution
                 time may gradually increase while using the
                 application. The key idea is to systematically search
                 for pairs of events where triggering one event
                 increases the execution time of the other event. For
                 example, this situation may happen because one event
                 accumulates data that is processed by the other event.
                 We implement the approach for JavaScript-based web
                 applications and apply it to three real-world
                 applications. EventBreak discovers events with an
                 execution time that gradually increases in an unbounded
                 way, which makes the application unresponsive, and
                 events that, if triggered repeatedly, reveal a severe
                 scalability problem, which makes the application
                 unusable. The approach reveals two known bugs and four
                 previously unknown responsiveness problems.
                 Furthermore, we show that EventBreak helps in testing
                 that event handlers avoid such problems by bounding a
                 handler's execution time.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '14 conference proceedings.",
}

@Article{Radoi:2014:TIC,
  author =       "Cosmin Radoi and Stephen J. Fink and Rodric Rabbah and
                 Manu Sridharan",
  title =        "Translating imperative code to {MapReduce}",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "10",
  pages =        "909--927",
  month =        oct,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2714064.2660228",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue May 12 17:41:21 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "We present an approach for automatic translation of
                 sequential, imperative code into a parallel MapReduce
                 framework. Automating such a translation is
                 challenging: imperative updates must be translated into
                 a functional MapReduce form in a manner that both
                 preserves semantics and enables parallelism. Our
                 approach works by first translating the input code into
                 a functional representation, with loops succinctly
                 represented by fold operations. Then, guided by rewrite
                 rules, our system searches a space of equivalent
                 programs for an effective MapReduce implementation. The
                 rules include a novel technique for handling irregular
                 loop-carried dependencies using group-by operations to
                 enable greater parallelism. We have implemented our
                 technique in a tool called Mold. It translates
                 sequential Java code into code targeting the Apache
                 Spark runtime. We evaluated Mold on several real-world
                 kernels and found that in most cases Mold generated the
                 desired MapReduce program, even for codes with complex
                 indirect updates.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '14 conference proceedings.",
}

@Article{Rathje:2014:FMC,
  author =       "William Rathje and Brad Richards",
  title =        "A framework for model checking {UDP} network programs
                 with {Java Pathfinder}",
  journal =      j-SIGADA-LETTERS,
  volume =       "34",
  number =       "3",
  pages =        "81--86",
  month =        dec,
  year =         "2014",
  CODEN =        "AALEE5",
  DOI =          "https://doi.org/10.1145/2692956.2663184",
  ISSN =         "1094-3641 (print), 1557-9476 (electronic)",
  ISSN-L =       "1094-3641",
  bibdate =      "Fri Feb 13 07:33:53 MST 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigada.bib",
  abstract =     "Complex asynchronous, distributed systems could
                 benefit significantly from model checking, but model
                 checking programs do not natively support verification
                 of distributed software. Several frameworks have been
                 developed recently that apply model checking to
                 networked software, but none of these frameworks
                 support complete modeling of programs that use the User
                 Datagram Protocol (UDP). This paper presents the first
                 framework to model realistic rather than ideal UDP
                 network operations using Java Pathfinder, and describes
                 its use in verifying a distributed UDP-based
                 application.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGADA Ada Letters",
  journal-URL =  "http://portal.acm.org/citation.cfm?id=J32",
  remark =       "HILT '14 conference proceedings.",
}

@Book{Rauschmayer:2014:SJD,
  author =       "Axel Rauschmayer",
  title =        "Speaking {JavaScript}: [an in-depth guide for
                 programmers]",
  publisher =    pub-ORA-MEDIA,
  address =      pub-ORA-MEDIA:adr,
  pages =        "xvii + 437",
  year =         "2014",
  ISBN =         "1-4493-6503-5",
  ISBN-13 =      "978-1-4493-6503-5",
  LCCN =         "QA76.73.J39 R38 2014",
  bibdate =      "Tue May 12 16:03:24 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/ora.bib;
                 https://www.math.utah.edu/pub/tex/bib/unicode.bib;
                 z3950.loc.gov:7090/Voyager",
  acknowledgement = ack-nhfb,
  author-dates = "1972--",
  subject =      "JavaScript (Computer program language); Application
                 software; Development; Web sites; Programming; Web site
                 development",
  tableofcontents = "Part I: JavaScript Quick Start \\
                 Basic JavaScript \\
                 Part II: Background \\
                 Why JavaScript? \\
                 The Nature of JavaScript \\
                 How JavaScript was created \\
                 Standardization: ECMAScript \\
                 Historical JavaScript Milestones \\
                 Part III: JavaScript in Depth \\
                 JavaScript's Syntax \\
                 Values \\
                 Operators \\
                 Booleans \\
                 Numbers \\
                 Strings \\
                 Statements \\
                 Exception Handling \\
                 Functions \\
                 Variables: Scopes, Environments, and Closures \\
                 Objects and Inheritance \\
                 Arrays \\
                 Regular Expressions \\
                 Dates \\
                 Math \\
                 JSON \\
                 Standard Global Variables \\
                 Unicode and JavaScript \\
                 New in ECMAScript 5 \\
                 Part IV: Tips, Tools, and Libraries \\
                 A Meta Code Style Guide \\
                 Language Mechanisms for Debugging \\
                 Subclassing Built-ins \\
                 JSDoc: Generating API Documentation \\
                 Libraries \\
                 Module Systems and Package Managers \\
                 More Tools \\
                 What to Do Next",
}

@Article{Reardon:2014:SSB,
  author =       "Susan Reardon and Brendan Tangney",
  title =        "{Smartphones}, Studio-Based Learning, and Scaffolding:
                 Helping Novices Learn to Program",
  journal =      j-TOCE,
  volume =       "14",
  number =       "4",
  pages =        "23:1--23:??",
  month =        dec,
  year =         "2014",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/2677089",
  ISSN =         "1946-6226",
  bibdate =      "Wed Feb 11 21:50:28 MST 2015",
  bibsource =    "http://www.acm.org/pubs/toce;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/toce.bib",
  abstract =     "This article describes how smartphones, studio-based
                 learning, and extensive scaffolding were used in
                 combination in the teaching of a freshman Introduction
                 to Programming course. To reduce cognitive overload, a
                 phased approach was followed in introducing programming
                 concepts and development environments, beginning with
                 the visual programming environment Scratch and
                 culminating with Java development for Android
                 smartphones. Studio-based learning, a pedagogical
                 approach long established in the fields of architecture
                 and design education, was used as the basis for a
                 collaborative social constructivist-and
                 constructionist-approach to learning. Smartphones
                 offered students the potential to develop applications
                 for a context that is both immediate and clearly
                 relevant to the ways in which they utilize and interact
                 with technology. The research was carried out over
                 three full academic years and included 53 student
                 participants. An exploratory case study methodology was
                 used to investigate the efficacy of the approach in
                 helping to overcome the barriers faced by novice
                 programmers. The findings indicate that the approach
                 has merit. The students were motivated and engaged by
                 the learning experience and were able to develop
                 sophisticated applications that incorporated images,
                 sound, arrays, and event handling. There is evidence
                 that aspects of the studio-based learning approach,
                 such as the scope that it gave students to innovate and
                 the open feedback during student presentations,
                 provided a learning environment that was motivating.
                 Overall, the combination of smartphones, studio-based
                 learning, and appropriate scaffolding offers an
                 effective way to teach introductory programming
                 courses.",
  acknowledgement = ack-nhfb,
  articleno =    "23",
  fjournal =     "ACM Transactions on Computing Education",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J1193",
}

@Article{Richard-Foy:2014:EHL,
  author =       "Julien Richard-Foy and Olivier Barais and Jean-Marc
                 J{\'e}z{\'e}quel",
  title =        "Efficient high-level abstractions for {Web}
                 programming",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "3",
  pages =        "53--60",
  month =        mar,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2637365.2517227",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Jun 26 05:58:25 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Writing large Web applications is known to be
                 difficult. One challenge comes from the fact that the
                 application's logic is scattered into heterogeneous
                 clients and servers, making it difficult to share code
                 between both sides or to move code from one side to the
                 other. Another challenge is performance: while Web
                 applications rely on ever more code on the client-side,
                 they may run on smart phones with limited hardware
                 capabilities. These two challenges raise the following
                 problem: how to benefit from high-level languages and
                 libraries making code complexity easier to manage and
                 abstracting over the clients and servers differences
                 without trading this ease of engineering for
                 performance? This article presents high-level
                 abstractions defined as deep embedded DSLs in Scala
                 that can generate efficient code leveraging the
                 characteristics of both client and server environments.
                 We compare performance on client-side against other
                 candidate technologies and against hand written
                 low-level JavaScript code. Though code written with our
                 DSL has a high level of abstraction, our benchmark on a
                 real world application reports that it runs as fast as
                 hand tuned low-level JavaScript code.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "GPCE '13 conference proceedings.",
}

@Book{Richardson:2014:BEL,
  author =       "Matt Richardson",
  title =        "{BeagleBone f{\"u}r Einsteiger: [Linux-basierte
                 Elektronik-Projekte mit Python und JavaScript]}",
  publisher =    pub-ORA,
  address =      pub-ORA:adr,
  pages =        "xii + 134",
  year =         "2014",
  ISBN =         "3-95561-409-3",
  ISBN-13 =      "978-3-95561-409-6",
  LCCN =         "????",
  bibdate =      "Thu Feb 26 14:22:56 MST 2015",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/linux.bib;
                 https://www.math.utah.edu/pub/tex/bib/python.bib;
                 https://www.math.utah.edu/pub/tex/bib/unix.bib",
  acknowledgement = ack-nhfb,
  language =     "German",
  subject =      "BeagleBone Black; BeagleBone; Digitalelektronik;
                 Hobbyelektronik; JavaScript; LINUX; Programmierung;
                 Python (Programmiersprache); Systemplattform",
}

@Article{Robatmili:2014:MRL,
  author =       "Behnam Robatmili and Calin Cascaval and Mehrdad
                 Reshadi and Madhukar N. Kedlaya and Seth Fowler and
                 Vrajesh Bhavsar and Michael Weber and Ben Hardekopf",
  title =        "{MuscalietJS}: rethinking layered dynamic web
                 runtimes",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "7",
  pages =        "77--88",
  month =        jul,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2674025.2576211",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Sep 26 07:29:50 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Layered JavaScript engines, in which the JavaScript
                 runtime is built on top another managed runtime,
                 provide better extensibility and portability compared
                 to traditional monolithic engines. In this paper, we
                 revisit the design of layered JavaScript engines and
                 propose a layered architecture, called MuscalietJS2,
                 that splits the responsibilities of a JavaScript engine
                 between a high-level, JavaScript-specific component and
                 a low-level, language-agnostic .NET VM. To make up for
                 the performance loss due to layering, we propose a two
                 pronged approach: high-level JavaScript optimizations
                 and exploitation of low-level VM features that produce
                 very efficient code for hot functions. We demonstrate
                 the validity of the MuscalietJS design through a
                 comprehensive evaluation using both the Sunspider
                 benchmarks and a set of web workloads. We demonstrate
                 that our approach outperforms other layered engines
                 such as IronJS and Rhino engines while providing
                 extensibility, adaptability and portability.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "VEE '14 conference proceedings.",
}

@Article{Rompf:2014:SPJ,
  author =       "Tiark Rompf and Arvind K. Sujeeth and Kevin J. Brown
                 and HyoukJoong Lee and Hassan Chafi and Kunle
                 Olukotun",
  title =        "Surgical precision {JIT} compilers",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "6",
  pages =        "41--52",
  month =        jun,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2666356.2594316",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Sep 26 07:38:28 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Just-in-time (JIT) compilation of running programs
                 provides more optimization opportunities than offline
                 compilation. Modern JIT compilers, such as those in
                 virtual machines like Oracle's HotSpot for Java or
                 Google's V8 for JavaScript, rely on dynamic profiling
                 as their key mechanism to guide optimizations. While
                 these JIT compilers offer good average performance,
                 their behavior is a black box and the achieved
                 performance is highly unpredictable. In this paper, we
                 propose to turn JIT compilation into a precision tool
                 by adding two essential and generic metaprogramming
                 facilities: First, allow programs to invoke JIT
                 compilation explicitly. This enables controlled
                 specialization of arbitrary code at run-time, in the
                 style of partial evaluation. It also enables the JIT
                 compiler to report warnings and errors to the program
                 when it is unable to compile a code path in the
                 demanded way. Second, allow the JIT compiler to call
                 back into the program to perform compile-time
                 computation. This lets the program itself define the
                 translation strategy for certain constructs on the fly
                 and gives rise to a powerful JIT macro facility that
                 enables ``smart'' libraries to supply domain-specific
                 compiler optimizations or safety checks. We present
                 Lancet, a JIT compiler framework for Java bytecode that
                 enables such a tight, two-way integration with the
                 running program. Lancet itself was derived from a
                 high-level Java bytecode interpreter: staging the
                 interpreter using LMS (Lightweight Modular Staging)
                 produced a simple bytecode compiler. Adding abstract
                 interpretation turned the simple compiler into an
                 optimizing compiler. This fact provides compelling
                 evidence for the scalability of the staged-interpreter
                 approach to compiler construction. In the case of
                 Lancet, JIT macros also provide a natural interface to
                 existing LMS-based toolchains such as the Delite
                 parallelism and DSL framework, which can now serve as
                 accelerator macros for arbitrary JVM bytecode.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  received =     "PLDI '14 conference proceedings.",
}

@Article{Rowe:2014:STA,
  author =       "Reuben N. S. Rowe and S. J. van Bakel",
  title =        "Semantic Types and Approximation for {Featherweight
                 Java}",
  journal =      j-THEOR-COMP-SCI,
  volume =       "517",
  number =       "??",
  pages =        "34--74",
  day =          "16",
  month =        jan,
  year =         "2014",
  CODEN =        "TCSCDI",
  ISSN =         "0304-3975 (print), 1879-2294 (electronic)",
  ISSN-L =       "0304-3975",
  bibdate =      "Wed Dec 18 14:01:23 MST 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/tcs2010.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0304397513006415",
  acknowledgement = ack-nhfb,
  fjournal =     "Theoretical Computer Science",
  journal-URL =  "http://www.sciencedirect.com/science/journal/03043975/",
}

@Article{Rubin:2014:HCW,
  author =       "Norm Rubin",
  title =        "Heterogeneous computing: what does it mean for
                 compiler research?",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "8",
  pages =        "315--316",
  month =        aug,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2692916.2558891",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Wed Nov 26 16:26:30 MST 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "The current trend in computer architecture is to
                 increase the number of cores, to create specialized
                 types of cores within a single machine, and to network
                 such machines together in very fluid web/cloud
                 computing arrangements. Compilers have traditionally
                 focused on optimizations to code that improve
                 performance, but is that the right target to speed up
                 real applications? Consider loading a web page (like
                 starting GMAIL) the page is transferred to the client,
                 any JavaScript is compiled, the JavaScript executes,
                 and the page gets displayed. The classic compiler model
                 (which was first developed in the late 50's) was a
                 great fit for single core machines but has fallen
                 behind architecture, and language. For example how do
                 you compile a single program for a machine that has
                 both a CPU and a graphics coprocessor (a GPU) with a
                 very different programming and memory model? Together
                 with the changes in architecture there have been
                 changes in programming languages. Dynamic languages are
                 used more, static languages are used less. How does
                 this effect compiler research? In this talk, I'll
                 review a number of traditional compiler research
                 challenges that have (or will) become burning issues
                 and will describe some new problems areas that were not
                 considered in the past. For example language
                 specifications are large complex technical documents
                 that are difficult for non-experts to follow.
                 Application programmers are often not willing to read
                 these documents; can a compiler bridge the gap?",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "PPoPP '14 conference proceedings.",
}

@Article{Samak:2014:MTS,
  author =       "Malavika Samak and Murali Krishna Ramanathan",
  title =        "Multithreaded test synthesis for deadlock detection",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "10",
  pages =        "473--489",
  month =        oct,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2714064.2660238",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue May 12 17:41:21 MDT 2015",
  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/sigplan2010.bib",
  abstract =     "Designing and implementing thread-safe multithreaded
                 libraries can be a daunting task as developers of these
                 libraries need to ensure that their implementations are
                 free from concurrency bugs, including deadlocks. The
                 usual practice involves employing software testing
                 and/or dynamic analysis to detect deadlocks. Their
                 effectiveness is dependent on well-designed
                 multithreaded test cases. Unsurprisingly, developing
                 multithreaded tests is significantly harder than
                 developing sequential tests for obvious reasons. In
                 this paper, we address the problem of automatically
                 synthesizing multithreaded tests that can induce
                 deadlocks. The key insight to our approach is that a
                 subset of the properties observed when a deadlock
                 manifests in a concurrent execution can also be
                 observed in a single threaded execution. We design a
                 novel, automatic, scalable and directed approach that
                 identifies these properties and synthesizes a deadlock
                 revealing multithreaded test. The input to our approach
                 is the library implementation under consideration and
                 the output is a set of deadlock revealing multithreaded
                 tests. We have implemented our approach as part of a
                 tool, named OMEN$^1$. OMEN is able to synthesize
                 multithreaded tests on many multithreaded Java
                 libraries. Applying a dynamic deadlock detector on the
                 execution of the synthesized tests results in the
                 detection of a number of deadlocks, including 35 real
                 deadlocks in classes documented as thread-safe.
                 Moreover, our experimental results show that dynamic
                 analysis on multithreaded tests that are either
                 synthesized randomly or developed by third-party
                 programmers are ineffective in detecting the
                 deadlocks.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '14 conference proceedings.",
}

@Article{Samak:2014:TDD,
  author =       "Malavika Samak and Murali Krishna Ramanathan",
  title =        "Trace driven dynamic deadlock detection and
                 reproduction",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "8",
  pages =        "29--42",
  month =        aug,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2692916.2555262",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Wed Nov 26 16:26:30 MST 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Dynamic analysis techniques have been proposed to
                 detect potential deadlocks. Analyzing and comprehending
                 each potential deadlock to determine whether the
                 deadlock is feasible in a real execution requires
                 significant programmer effort. Moreover, empirical
                 evidence shows that existing analyses are quite
                 imprecise. This imprecision of the analyses further
                 void the manual effort invested in reasoning about
                 non-existent defects. In this paper, we address the
                 problems of imprecision of existing analyses and the
                 subsequent manual effort necessary to reason about
                 deadlocks. We propose a novel approach for deadlock
                 detection by designing a dynamic analysis that
                 intelligently leverages execution traces. To reduce the
                 manual effort, we replay the program by making the
                 execution follow a schedule derived based on the
                 observed trace. For a real deadlock, its feasibility is
                 automatically verified if the replay causes the
                 execution to deadlock. We have implemented our approach
                 as part of WOLF and have analyzed many large (upto
                 160KLoC) Java programs. Our experimental results show
                 that we are able to identify 74\% of the reported
                 defects as true (or false) positives automatically
                 leaving very few defects for manual analysis. The
                 overhead of our approach is negligible making it a
                 compelling tool for practical adoption.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "PPoPP '14 conference proceedings.",
}

@Article{Sarimbekov:2014:JCS,
  author =       "Aibek Sarimbekov and Andreas Sewe and Walter Binder
                 and Philippe Moret and Mira Mezini",
  title =        "{JP2}: {Call}-site aware calling context profiling for
                 the {Java Virtual Machine}",
  journal =      j-SCI-COMPUT-PROGRAM,
  volume =       "79",
  number =       "??",
  pages =        "146--157",
  day =          "1",
  month =        jan,
  year =         "2014",
  CODEN =        "SCPGD4",
  ISSN =         "0167-6423 (print), 1872-7964 (electronic)",
  ISSN-L =       "0167-6423",
  bibdate =      "Sat Nov 30 15:06:12 MST 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/scicomputprogram.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib;
                 http://www.sciencedirect.com/science/journal/01676423",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0167642311002036",
  acknowledgement = ack-nhfb,
  fjournal =     "Science of Computer Programming",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01676423",
}

@Article{Savrun-Yeniceri:2014:EHI,
  author =       "G{\"u}lfem Savrun-Yeni{\c{c}}eri and Wei Zhang and
                 Huahan Zhang and Eric Seckler and Chen Li and Stefan
                 Brunthaler and Per Larsen and Michael Franz",
  title =        "Efficient hosted interpreters on the {JVM}",
  journal =      j-TACO,
  volume =       "11",
  number =       "1",
  pages =        "9:1--9:24",
  month =        feb,
  year =         "2014",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/2532642",
  ISSN =         "1544-3566 (print), 1544-3973 (electronic)",
  ISSN-L =       "1544-3566",
  bibdate =      "Tue Mar 10 08:08:33 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/taco.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/2532642",
  abstract =     "Many guest languages are implemented using the Java
                 Virtual Machine (JVM) as a host environment. There are
                 two major implementation choices: custom compilers and
                 so-called hosted interpreters. Custom compilers are
                 complex to build but offer good performance. Hosted
                 interpreters are comparatively simpler to implement but
                 until now have suffered from poor performance.\par

                 We studied the performance of hosted interpreters and
                 identified common bottlenecks preventing their
                 efficient execution. First, similar to interpreters
                 written in C/C++, instruction dispatch is expensive on
                 the JVM. Second, Java's semantics require expensive
                 runtime exception checks that negatively affect array
                 performance essential to interpreters.\par

                 We present two optimizations targeting these
                 bottlenecks and show that the performance of optimized
                 interpreters increases dramatically: we report speedups
                 by a factor of up to 2.45 over the Jython interpreter,
                 3.57 over the Rhino interpreter, and 2.52 over the
                 JRuby interpreter, respectively. The resulting
                 performance is comparable with that of custom
                 compilers. Our optimizations are enabled by a few
                 simple annotations that require only modest
                 implementation effort; in return, performance increases
                 substantially.",
  acknowledgement = ack-nhfb,
  articleno =    "9",
  fjournal =     "ACM Transactions on Architecture and Code Optimization
                 (TACO)",
  journal-URL =  "https://dl.acm.org/loi/taco",
}

@Book{Schildt:2014:JCRb,
  editor =       "Herbert Schildt",
  title =        "{Java}: The Complete Reference",
  publisher =    pub-MCGRAW-HILL,
  address =      pub-MCGRAW-HILL:adr,
  edition =      "Ninth",
  pages =        "xxxiv + 1274",
  year =         "2014",
  ISBN =         "0-07-180855-8 (paperback), 0-07-180925-2,
                 0-07-180856-6",
  ISBN-13 =      "978-0-07-180855-2, 978-0-07-180925-2,
                 978-0-07-180856-9",
  LCCN =         "QA76.73.J38 S332 2014eb",
  bibdate =      "Thu Dec 4 13:05:57 MST 2014",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "Fully updated for Java SE 8, this edition explains how
                 to develop, compile, debug, and run Java programs. The
                 book covers the entire Java language, including its
                 syntax, keywords, and fundamental programming
                 principles, as well as significant portions of the Java
                 API library. JavaBeans, servlets, applets, and Swing
                 are examined and real-world examples demonstrate Java
                 in action. New Java SE 8 features such as lambda
                 expressions, the stream library, and the default
                 interface method are discussed in detail. This Oracle
                 Press resource also offers a solid introduction to
                 JavaFX. Topics covered include: data types, variables,
                 arrays, and operators; control statements; classes,
                 objects, and methods; method overloading and
                 overriding; inheritance; interfaces and packages;
                 exception handling; multithreaded programming;
                 enumerations, autoboxing, and annotations; I/O classes;
                 generics; lambda expressions; string handlin;
                 collections framework; networking; event handling; AWT
                 and Swing; concurrent and stream API; regular
                 expressions; JavaFX; JavaBeans; and applets and
                 servlets.",
  acknowledgement = ack-nhfb,
  shorttableofcontents = "The history and evolution of Java \\
                 An overview of Java \\
                 Data types, variables, and arrays \\
                 Operators \\
                 Control statements \\
                 Introducing classes \\
                 A closer look at methods and classes \\
                 Inheritance \\
                 Packages and interfaces \\
                 Exception handling \\
                 Multithreaded programming \\
                 Enumerations, autoboxing, and annotations (metadata)
                 \\
                 I/O, applets, and other topics \\
                 Generics \\
                 Lambda expressions \\
                 String handling \\
                 Exploring java.lang \\
                 Java.util part 1: the collections framework \\
                 Java.util part 2: more utility classes \\
                 Input/output: exploring java.io \\
                 Exploring NIO \\
                 Networking \\
                 The applet class \\
                 Event handling \\
                 Introducing the AWT: working with windows, graphics,
                 and text \\
                 Using AWT controls, layout managers, and menus \\
                 Images \\
                 The concurrency utilities \\
                 The stream API \\
                 Regular expressions and other packages \\
                 Introducing swing \\
                 Exploring swing \\
                 Introducing swing menus \\
                 Introducing JavaFX GUI programming \\
                 Exploring JavaFX controls \\
                 Introducing JavaFX menus \\
                 Java beans \\
                 Introducing servlets \\
                 Using Java's documentation comments",
  subject =      "Java (Langage de programmation); Programmation
                 Internet; Java (Computer program language); Internet
                 programming; Internet programming.; Java (Computer
                 program language)",
  tableofcontents = "Part I. The Java language \\
                 1. The history and evolution of Java: Java's lineage;
                 The creation of Java; How Java changed the Internet;
                 Java's magic: the bytecode; Servlets: Java on the
                 server side; The Java buzzwords; The evolution of Java;
                 Java SE 8; A culture of innovation \\
                 2. An overview of Java: Object-oriented programming; A
                 first simple program; A second short program; Two
                 control statements; Using blocks of code; Lexical
                 issues; The Java class libraries \\
                 3. Data types, variables, and arrays: Java is a
                 strongly typed language; The primitive types; Integers;
                 Floating-point types; Characters; Booleans; A closer
                 look at literals; Variables; Type conversion and
                 casting; Automatic type promotion in expressions;
                 Arrays; A few words about strings; A note to C/C++
                 programmers about pointers \\
                 4. Operators: Arithmetic operators; The bitwise
                 operators; Relational operators; Boolean logical
                 operators; The assignment operator; The ? operator;
                 Operator precedence; Using parentheses \\
                 5. Control statements: Java's selection statements;
                 Iteration statements; Jump statements \\
                 6. Introducing classes: Class fundamentals; Declaring
                 objects; Assigning object reference variables;
                 Introducing methods; Constructors; The this keyword;
                 Garbage collection; The finalize() method; A stack
                 class \\
                 7. A closer look at methods and classes: Overloading
                 methods; Using objects as parameters; A closer look at
                 argument passing; Returning objects; Recursion;
                 Introducing access control; Understanding static;
                 Introducing final; Arrays revisited; Introducing nested
                 and inner classes; Exploring the string class; Using
                 command-line arguments; Varargs: variable-length
                 arguments \\
                 8. Inheritance: Inheritance basics; Using super;
                 Creating a multilevel hierarchy; When constructors are
                 executed; Method overriding; Dynamic method dispatch;
                 Using abstract classes; Using final with inheritance;
                 The object class \\
                 9. Packages and interfaces: Packages; Access
                 protection; Importing packages; Interfaces; Default
                 interface methods; Use static methods in an interface;
                 Final thoughts on packages and interfaces \\
                 10. Exception handling: Exception-handling
                 fundamentals; Exception types; Uncaught exceptions;
                 Using try and catch; Multiple catch clauses; Nested try
                 statements; Throw; Throws; Finally; Java's build-in
                 exceptions; Creating your own exception subclasses;
                 Chained exceptions; Three recently added exception
                 features; Using exceptions \\
                 11. Multithreaded programming: The Java thread model;
                 The main thread; Creating a thread; Creating multiple
                 threads; Using isAlive() and join(); Thread priorities;
                 Synchronization; Interthread communication; Suspending,
                 resuming, and stopping threads; Obtaining a thread's
                 state; Using multithreading \\
                 12. Enumerations, autoboxing, and annotations
                 (metadata): Enumerations; Type wrappers; Autoboxing;
                 Annotations (metadata); Type annotations; Repeating
                 annotations \\
                 13. I/O, applets, and other topics: I/O basics; Reading
                 console input; Writing console output; The PrintWriter
                 class; Reading and writing files; Automatically closing
                 a file; Applet fundamentals; The transient and volatile
                 modifiers; Using instanceof; Strictfp; Native methods;
                 Problems with native methods; Using assert; Static
                 import; Invoking overloaded constructors through
                 this(); Compact API profiles \\
                 14. Generics: What are generics?; A simple generics
                 example; A generic class with two type parameters; The
                 general form of a generic class; Bounded types; Using
                 wildcard arguments; Creating a generic method; Generic
                 interfaces; Raw types and legacy code; Generic class
                 hierarchies; Type inference with generics; Erasure;
                 Ambiguity errors; Some generic restrictions \\
                 15. Lambda expressions: Introducing lambda expressions;
                 Block lambda expressions; Generic functional
                 interfaces; Passing lambda expressions as arguments;
                 Lambda expressions and exceptions; Lambda expressions
                 and variable capture; Method references; Constructor
                 references; Predefined functional interfaces \\
                 Part II. The Java library. \\
                 16. String handling: The string constructors; String
                 length; Special string operations; Character
                 extraction; String comparison; Searching strings;
                 Modifying a string; Data conversion using valueOf();
                 Changing the case of characters within a string;
                 Joining strings; Additional string methods;
                 StringBuffer; StringBuilder \\
                 17. Exploring java.lang: Primitive type wrappers; Void;
                 Process; Runtime; ProcessBuilder; System; Object; Using
                 clone() and the cloneable interface; Class;
                 ClassLoader; Math; StrictMath; Compiler; Thread,
                 ThreadGroup and runnable; ThreadLocal and
                 InheritableThreadLocal; Package; RuntimePermission;
                 Throwable; SecurityManager; StackTraceElement; Enum;
                 ClassValue; The CharSequence interface; The comparable
                 interface; The appendable interface; The iterable
                 interface; The readable interface; The AutoCloseable
                 interface; The Thread.UncaughtExceptionHandler
                 interface; The java.lang subpackages \\
                 18. java.util Part 1: The collections framework:
                 Collections overview; JDK 5 changed the collections
                 framework; The collection interfaces; The collection
                 classes; Accessing a collection via an iterator;
                 Spliterators; Storing user-defined classes in
                 collections; The RandomAccess interface; Working with
                 maps; Comparators; The collection algorithms; Arrays;
                 The legacy classes and interfaces; Parting thoughts on
                 collections \\
                 19. java.util Part 2: More utility classes:
                 StringTokenizer; BitSet; Optional, OptionalDouble,
                 OptionalInt, and OptionalLong; Date; Calendar;
                 GregorianCalendar; TimeZone; SimpleTimeZone; Locale;
                 Random; Observable; Timer and TimerTask; Currency;
                 Formatter; Scanner; The ResourceBundle,
                 ListResourceBundle, and PropertyResourceBundle classes;
                 Miscellaneous utility classes and interfaces; The
                 java.util subpackages \\
                 20. Input/output: exploring java.io: The I/O classes
                 and interfaces; File; The AutoCloseable, Closeable, and
                 flushable interfaces; I/O exceptions; Two ways to close
                 a stream; The stream classes; The byte streams; The
                 character streams; The console class; Serialization;
                 Stream benefits \\
                 21. Exploring NIO: The NIO classes; NIO fundamentals;
                 Enhancements added to NIO by JDK 7; Using the NIO
                 system; Pre-JDK 7 channel-based examples \\
                 22. Networking: Networking basics; The networking
                 classes and interfaces; Inet/Address; Inet4Address and
                 Inet6Address; TCP/IP client sockets; URL;
                 URLConnection; HttpURLConnection; The URI class;
                 Cookies; TCP/IP server sockets; Datagrams \\
                 23. The applet class: Two types of applets; Applet
                 basics; Applet architecture; An applet skeleton; Simple
                 applet display methods; Requesting repainting; Using
                 the status window; The HTML APPLET tag; Passing
                 parameters to applets; getDocumentBase() and
                 getCodeBase(); AppletContext and showDocument(); The
                 AudioClip interface; The AppletStub interface;
                 Outputting to the console \\
                 24. Event handling: Two event handling mechanisms; The
                 delegation event model; Event classes; The KeyEvent
                 class; Sources of events; Event listener interfaces;
                 Using the delegation event model; Adapter classes;
                 Inner classes \\
                 25. Introducing the AWT: working with windows,
                 graphics, and text: AWT classes; Window fundamentals;
                 Working with frame windows; Creating a frame window in
                 an AWT-based applet; Creating a windowed program;
                 Displaying information within a window; Introducing
                 graphics; Working with color; Setting the paint mode;
                 Working with fonts; Managing text output using
                 FontMetrics \\
                 26. Using AWT controls, layout managers, and menus: AWT
                 control fundamentals; Labels; Using buttons; Applying
                 check boxes; CheckboxGroup; Choice controls; Using
                 lists; Managing scroll bars; Using a TextField; Using a
                 TextArea; Understanding layout managers; Menu bars and
                 menus; Dialog boxes; FileDialog; A word about
                 overriding paint() \\
                 27. Images: File formats; Image fundamentals: creating,
                 loading, and displaying; ImageObserver; Double
                 buffering; MediaTracker; ImageProducer; ImageConsumer;
                 ImageFilter; Additional imaging classes \\
                 28. The concurrency utilities: The concurrent API
                 packages; Using synchronization objects; Phaser; Using
                 an executor; The TimeUnit enumeration; the concurrent
                 collections; Locks; Atomic operations; Parallel
                 programming via the fork/join framework; The
                 concurrency utilities versus Java's traditional
                 approach \\
                 29. The stream API: Stream basics; Reduction
                 operations; Using parallel streams; Mapping;
                 Collecting; Iterators and streams; More to explore in
                 the stream API \\
                 30. Regular expressions and other packages: The core
                 Java API packages; Regular expression processing;
                 Reflection; Remote method invocation (RMI); Formatting
                 date and time with java.text; The time and date API
                 added by JDK 8 \\
                 Part III. Introducing GUI programming with swing \\
                 31. Introducing swing: The origins of swing; Swing is
                 built on the AWT; Two key swing features; The MVC
                 connection; Components and containers; The swing
                 packages; A simple swing application; Event handling;
                 Create a swing applet; Painting in swing \\
                 32. Exploring swing: JLabel and ImageIcon; JTextField;
                 The swing buttons; JTabbedPane; JScrollPane; JList;
                 JComboBox; Trees; JTable \\
                 33. Introducing swing menus: Menu basics; An overview
                 of JMenuBar, JMenu, and JMenuItem; Create a main menu;
                 Add Mnemonics and accelerators to menu items; Add
                 images and tooltips to menu items; Use
                 JRadioButtonMenuItem and JCheckBoxMenuItem; Create a
                 popup menu; Create a toolbar; Use actions; Put the
                 entire MenuDemo program together; Continuing your
                 exploration of swing \\
                 Part IV. Introducing GUI programming with JavaFX \\
                 34. Introducing JavaFX GUI programming: JavaFX basic
                 concepts; A JavaFX application skeleton; Compiling and
                 running a JavaFX program; The application thread; A
                 simple JavaFX control: label; Using buttons and events;
                 Drawing directly on a canvas \\
                 35. Exploring JavaFX controls: Using image and
                 ImageView; ToggleButton; RadioButton; CheckBox;
                 ListView; ComboBox; TextField; ScrollPane; TreeView;
                 Introducing effects and transforms; Adding tooltips;
                 Disabling a control \\
                 36. Introducing JavaFX menus: Menu basics; An overview
                 of MenuBar, Menu, and MenuItem; Create a main menu; Add
                 mnemonics and accelerators to menu items; Add images to
                 menu items; Use RadioMenuItem and CheckMenuItem; Create
                 a context menu; Create a toolbar; Put the entire
                 MenuDemo program together; Continuing your exploration
                 of JavaFX \\
                 Part V. Applying Java \\
                 37. Java beans: What is a Java bean?; Advantages of
                 Java beans; Introspection; Bound and constrained
                 properties; Persistence; Customizers; The Java beans
                 API; A bean example \\
                 38. Introducing servlets: Background; The life cycle of
                 a servlet; Servlet development options; Using Tomcat; A
                 simple servlet; The servlet API; The javax.servlet
                 package; Reading servlet parameters; The
                 javax.servlet.http package; Handling HTTP requests and
                 responses; Using cookies; Session tracking \\
                 Appendix. Using Java's documentation comments: The
                 javadoc tags; The general form of a documentation
                 comment; What javadoc outputs; An example that uses
                 documentation comments",
}

@Article{Shahriyar:2014:FCG,
  author =       "Rifat Shahriyar and Stephen M. Blackburn and Kathryn
                 S. McKinley",
  title =        "Fast conservative garbage collection",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "10",
  pages =        "121--139",
  month =        oct,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2714064.2660198",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue May 12 17:41:21 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Garbage collectors are exact or conservative. An exact
                 collector identifies all references precisely and may
                 move referents and update references, whereas a
                 conservative collector treats one or more of stack,
                 register, and heap references as ambiguous. Ambiguous
                 references constrain collectors in two ways. (1) Since
                 they may be pointers, the collectors must retain
                 referents. (2) Since they may be values, the collectors
                 cannot modify them, pinning their referents. We explore
                 conservative collectors for managed languages, with
                 ambiguous stacks and registers. We show that for Java
                 benchmarks they retain and pin remarkably few heap
                 objects: $ < 0.01 \% $ are falsely retained and 0.03\%
                 are pinned. The larger effect is collector design.
                 Prior conservative collectors (1) use mark-sweep and
                 unnecessarily forgo moving all objects, or (2) use
                 mostly copying and pin entire pages. Compared to
                 generational collection, overheads are substantial:
                 12\% and 45\% respectively. We introduce high
                 performance conservative Immix and reference counting
                 (RC). Immix is a mark-region collector with fine line
                 -grain pinning and opportunistic copying of unambiguous
                 referents. Deferred RC simply needs an object map to
                 deliver the first conservative RC. We implement six
                 exact collectors and their conservative counterparts.
                 Conservative Immix and RC come within 2 to 3\% of their
                 exact counterparts. In particular, conservative RC
                 Immix is slightly faster than a well-tuned exact
                 generational collector. These findings show that for
                 managed languages, conservative collection is
                 compatible with high performance.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '14 conference proceedings.",
}

@Article{Sor:2014:MLD,
  author =       "Vladimir Sor and Satish Narayana Srirama",
  title =        "Memory leak detection in {Java}: Taxonomy and
                 classification of approaches",
  journal =      j-J-SYST-SOFTW,
  volume =       "96",
  number =       "??",
  pages =        "139--151",
  month =        oct,
  year =         "2014",
  CODEN =        "JSSODM",
  ISSN =         "0164-1212 (print), 1873-1228 (electronic)",
  ISSN-L =       "0164-1212",
  bibdate =      "Mon Sep 1 11:31:01 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/jsystsoftw.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0164121214001423",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Systems and Software",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01641212/",
}

@Book{Stark:2014:JJV,
  author =       "Robert F. St{\"a}rk and Joachim Schmid and Egon
                 B{\"o}rger",
  title =        "{Java} and the {Java Virtual Machine}: Definition,
                 Verification, Validation",
  publisher =    pub-SV,
  address =      pub-SV:adr,
  pages =        "x + 381",
  year =         "2014",
  DOI =          "https://doi.org/10.1007/978-3-642-59495-3",
  ISBN =         "3-642-63997-6",
  ISBN-13 =      "978-3-642-63997-5",
  LCCN =         "QA76.76.C65",
  bibdate =      "Mon Jan 16 16:02:58 MST 2017",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  note =         "Softcover reprint of \cite{Stark:2001:JJV}.",
  URL =          "http://deposit.d-nb.de/cgi-bin/dokserv?id=4745749\%26prov=M\%26dok\_var=1\%26dok\_ext=htm",
  abstract =     "This book provides a high-level description, together
                 with a mathematical and an experimental analysis, of
                 Java and of the Java Virtual Machine (JVM), including a
                 standard compiler of Java programs to JVM code and the
                 security critical bytecode verifier component of the
                 JVM. The description is structured into language layers
                 and machine components. It comes with a natural
                 executable refinement which can be used for testing
                 code. The method developed for this purpose is based on
                 Abstract State Machines (ASMs) and can be applied to
                 other virtual machines and to other programming
                 languages as well. The book is written for advanced
                 students and for professionals and practitioners in
                 research and development who need for their work a
                 complete and transparent definition and an executable
                 model of the language and of the virtual machine
                 underlying its intended implementation.",
  acknowledgement = ack-nhfb,
  tableofcontents = "Introduction \\
                 Abstract State Machines \\
                 Part I. Java \\
                 Part II. Compilation of Java: The Trustful JVM \\
                 Part III. Bytecode Verification: The Secure JVM \\
                 Appendix \\
                 Index",
}

@Article{Steele:2014:FSP,
  author =       "Guy L. {Steele, Jr.} and Doug Lea and Christine H.
                 Flood",
  title =        "Fast splittable pseudorandom number generators",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "10",
  pages =        "453--472",
  month =        oct,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2714064.2660195",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue May 12 17:41:21 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/bibnet/authors/m/marsaglia-george.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/jstatsoft.bib;
                 https://www.math.utah.edu/pub/tex/bib/mathcw.bib;
                 https://www.math.utah.edu/pub/tex/bib/multithreading.bib;
                 https://www.math.utah.edu/pub/tex/bib/prng.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/tomacs.bib",
  abstract =     "We describe a new algorithm SplitMix for an
                 object-oriented and splittable pseudorandom number
                 generator (PRNG) that is quite fast: 9 64-bit
                 arithmetic/logical operations per 64 bits generated. A
                 conventional linear PRNG object provides a generate
                 method that returns one pseudorandom value and updates
                 the state of the PRNG, but a splittable PRNG object
                 also has a second operation, split, that replaces the
                 original PRNG object with two (seemingly) independent
                 PRNG objects, by creating and returning a new such
                 object and updating the state of the original object.
                 Splittable PRNG objects make it easy to organize the
                 use of pseudorandom numbers in multithreaded programs
                 structured using fork-join parallelism. No locking or
                 synchronization is required (other than the usual
                 memory fence immediately after object creation).
                 Because the generate method has no loops or
                 conditionals, it is suitable for SIMD or GPU
                 implementation. We derive SplitMix from the DotMix
                 algorithm of Leiserson, Schardl, and Sukha by making a
                 series of program transformations and engineering
                 improvements. The end result is an object-oriented
                 version of the purely functional API used in the
                 Haskell library for over a decade, but SplitMix is
                 faster and produces pseudorandom sequences of higher
                 quality; it is also far superior in quality and speed
                 to java.util.Random, and has been included in Java JDK8
                 as the class java.util.SplittableRandom. We have tested
                 the pseudorandom sequences produced by SplitMix using
                 two standard statistical test suites (DieHarder and
                 TestU01) and they appear to be adequate for
                 ``everyday'' use, such as in Monte Carlo algorithms and
                 randomized data structures where speed is important.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark-1 =     "OOPSLA '14 conference proceedings.",
  remark-2 =     "On page 466, the authors describe an interesting
                 technique for improving a user-supplied seed that might
                 produce insufficient randomness in the next several
                 members of the random-number sequence: ``Long runs of
                 0-bits or of 1-bits in the $\gamma$ [candidate seed]
                 value do not cause bits of the seed to flip; an
                 approximate proxy for how many bits of the seed will
                 flip might be the number of bit pairs of the form 01 or
                 10 in the candidate $\gamma$ value {\tt z}. Therefore
                 we require that the number of such pairs, as computed
                 by {\tt Long.bitCount(z ^ (z >>> 1))}, exceed 24; if it
                 does not, then the candidate z is replaced by the XOR
                 of {\tt z} and {\tt 0xaaaaaaaaaaaaaaaaL}, a constant
                 chosen so that (a) the low bit of {\tt z} remains 1,
                 and (b) every bit pair of the form 00 or 11 becomes
                 either 01 or 10, and likewise every bit pair of the
                 form 01 or 10 becomes either 00 or 11, so the new value
                 necessarily has more than 24 bit pairs whose bits
                 differ. Testing shows that this trick appears to be
                 effective.''",
  remark-3 =     "From page 468: ``we did three runs of TestU01 BigCrush
                 on {\tt java.util.Random}; 19 tests produced clear
                 failure on all three runs. These included 9 Birthday
                 Spacings tests, 8 ClosePairs tests, a WeightDistrib
                 test, and a CouponCollector test. This confirms
                 L'Ecuyer's observation that {\tt java.util.Random}
                 tends to fail Birthday Spacings tests [17].'' The
                 reference is to \cite{LEcuyer:2001:SUR}.",
  remark-4 =     "From page 470: ``[L'Ecuyer] comments, `In the Java
                 class {\tt java.util.Random}, RNG streams can be
                 declared and constructed dynamically, without limit on
                 their number. However, no precaution seems to have been
                 taken regarding the independence of these streams.'''",
  remark-5 =     "From page 471: ``They [the generators in this paper]
                 should not be used for cryptographic or security
                 applications, because they are too predictable (the
                 mixing functions are easily inverted, and two
                 successive outputs suffice to reconstruct the internal
                 state), \ldots{} One version seems especially suitable
                 for use as a replacement for {\tt java.util.Random},
                 because it produces sequences of higher quality, is
                 faster in sequential use, is easily parallelized for
                 use in JDK8 stream expressions, and is amenable to
                 efficient implementation on SIMD and GPU
                 architectures.''",
}

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

@Article{Stork:2014:APB,
  author =       "Sven Stork and Karl Naden and Joshua Sunshine and
                 Manual Mohr and Alcides Fonseca and Paulo Marques and
                 Jonathan Aldrich",
  title =        "{{\AE}minium}: a permission based
                 concurrent-by-default programming language approach",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "6",
  pages =        "26--26",
  month =        jun,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2666356.2594344",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Sep 26 07:38:28 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "The aim of {\AE}MINIUM is to study the implications of
                 having a concurrent-by-default programming language.
                 This includes language design, runtime system,
                 performance and software engineering considerations. We
                 conduct our study through the design of the
                 concurrent-by-default {\AE}MINIUM programming language.
                 {\AE}MINIUM leverages the permission flow of object and
                 group permissions through the program to validate the
                 program's correctness and to automatically infer a
                 possible parallelization strategy via a dataflow graph.
                 {\AE}MINIUM supports not only fork-join parallelism but
                 more general dataflow patterns of parallelism. In this
                 paper we present a formal system, called \mu
                 {\AE}MINIUM, modeling the core concepts of {\AE}MINIUM.
                 \mu {\AE}MINIUM's static type system is based on
                 Featherweight Java with {\AE}MINIUM-specific
                 extensions. Besides checking for correctness
                 {\AE}MINIUM's type system it also uses the permission
                 flow to compute a potential parallel execution strategy
                 for the program. \mu {\AE}MINIUM's dynamic semantics
                 use a concurrent-by-default evaluation approach. Along
                 with the formal system we present its soundness proof.
                 We provide a full description of the implementation
                 along with the description of various optimization
                 techniques we used. We implemented {\AE}MINIUM as an
                 extension of the Plaid programming language, which has
                 first-class support for permissions built-in. The
                 {\AE}MINIUM implementation and all case studies are
                 publicly available under the General Public License. We
                 use various case studies to evaluate {\AE}MINIUM's
                 applicability and to demonstrate that {\AE}MINIUM
                 parallelized code has performance improvements compared
                 to its sequential counterpart. We chose to use case
                 studies from common domains or problems that are known
                 to benefit from parallelization, to show that
                 {\AE}MINIUM is powerful enough to encode them. We
                 demonstrate through a webserver application, which
                 evaluates {\AE}MINIUM's impact on latency-bound
                 applications, that {\AE}MINIUM can achieve a 70\%
                 performance improvement over the sequential
                 counterpart. In another case study we chose to
                 implement a dictionary function to evaluate
                 {\AE}MINIUM's capabilities to express essential data
                 structures. Our evaluation demonstrates that
                 {\AE}MINIUM can be used to express parallelism in such
                 data-structures and that the performance benefits scale
                 with the amount of annotation effort which is put into
                 the implementation. We chose an integral
                 computationally example to evaluate pure functional
                 programming and computational intensive use cases. Our
                 experiments show that {\AE}MINIUM is capable of
                 extracting parallelism from functional code and
                 achieving performance improvements up to the limits of
                 Plaid's inherent performance bounds. Overall, we hope
                 that the work helps to advance concurrent programming
                 in modern programming environments.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  received =     "PLDI '14 conference proceedings.",
}

@Article{Su:2014:CEM,
  author =       "Xueyuan Su and Garret Swart and Brian Goetz and Brian
                 Oliver and Paul Sandoz",
  title =        "Changing engines in midstream: a {Java} stream
                 computational model for big data processing",
  journal =      j-PROC-VLDB-ENDOWMENT,
  volume =       "7",
  number =       "13",
  pages =        "1343--1354",
  month =        aug,
  year =         "2014",
  CODEN =        "????",
  ISSN =         "2150-8097",
  bibdate =      "Wed Feb 4 17:20:31 MST 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/vldbe.bib",
  abstract =     "With the addition of lambda expressions and the Stream
                 API in Java 8, Java has gained a powerful and
                 expressive query language that operates over in-memory
                 collections of Java objects, making the transformation
                 and analysis of data more convenient, scalable and
                 efficient. In this paper, we build on Java 8 Stream and
                 add a DistributableStream abstraction that supports
                 federated query execution over an extensible set of
                 distributed compute engines. Each query eventually
                 results in the creation of a materialized result that
                 is returned either as a local object or as an engine
                 defined distributed Java Collection that can be saved
                 and/or used as a source for future queries.
                 Distinctively, DistributableStream supports the
                 changing of compute engines both between and within a
                 query, allowing different parts of a computation to be
                 executed on different platforms. At execution time, the
                 query is organized as a sequence of pipelined stages,
                 each stage potentially running on a different engine.
                 Each node that is part of a stage executes its portion
                 of the computation on the data available locally or
                 produced by the previous stage of the computation. This
                 approach allows for computations to be assigned to
                 engines based on pricing, data locality, and resource
                 availability. Coupled with the inherent laziness of
                 stream operations, this brings great flexibility to
                 query planning and separates the semantics of the query
                 from the details of the engine used to execute it. We
                 currently support three engines, Local, Apache Hadoop
                 MapReduce and Oracle Coherence, and we illustrate how
                 new engines and data sources can be added.",
  acknowledgement = ack-nhfb,
  fjournal =     "Proceedings of the VLDB Endowment",
  journal-URL =  "http://portal.acm.org/citation.cfm?id=J1174",
}

@Article{Su:2014:RVP,
  author =       "Tzu-Hsiang Su and Hsiang-Jen Tsai and Keng-Hao Yang
                 and Po-Chun Chang and Tien-Fu Chen and Yi-Ting Zhao",
  title =        "Reconfigurable vertical profiling framework for the
                 {Android} runtime system",
  journal =      j-TECS,
  volume =       "13",
  number =       "2s",
  pages =        "59:1--59:??",
  month =        jan,
  year =         "2014",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/2544375.2544379",
  ISSN =         "1539-9087 (print), 1558-3465 (electronic)",
  ISSN-L =       "1539-9087",
  bibdate =      "Tue Jan 28 17:34:43 MST 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/tecs.bib",
  abstract =     "Dalvik virtual machine in the Android system creates a
                 profiling barrier between VM-space applications and
                 Linux user-space libraries. It is difficult for
                 existing profiling tools on the Android system to
                 definitively identify whether a bottleneck occurred in
                 the application level, the Linux user-space level, or
                 the Linux kernel level. Information barriers exist
                 between VM-space applications and Linux native analysis
                 tools due to runtime virtual machines' dynamic memory
                 allocation mechanism. Furthermore, traditional vertical
                 profiling tools targeted for Java virtual machines
                 cannot be simply applied on the Dalvik virtual machine
                 due to its unique design. The proposed the
                 Reconfigurable Vertical Profiling Framework bridges the
                 information gap and streamlines the hardware-software
                 co-design process for the Android runtime system.",
  acknowledgement = ack-nhfb,
  articleno =    "59",
  fjournal =     "ACM Transactions on Embedded Computing Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?&idx=J840",
}

@Article{Sverdlove:2014:JVL,
  author =       "Harry Sverdlove",
  title =        "The {Java} vulnerability landscape",
  journal =      j-NETWORK-SECURITY,
  volume =       "2014",
  number =       "4",
  pages =        "9--14",
  month =        apr,
  year =         "2014",
  CODEN =        "NTSCF5",
  DOI =          "https://doi.org/10.1016/S1353-4858(14)70041-8",
  ISSN =         "1353-4858 (print), 1872-9371 (electronic)",
  ISSN-L =       "1353-4858",
  bibdate =      "Mon Dec 4 17:01:06 MST 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/network-security.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S1353485814700418",
  acknowledgement = ack-nhfb,
  fjournal =     "Network Security",
  journal-URL =  "https://www.sciencedirect.com/journal/network-security",
}

@Article{Swamy:2014:GTE,
  author =       "Nikhil Swamy and Cedric Fournet and Aseem Rastogi and
                 Karthikeyan Bhargavan and Juan Chen and Pierre-Yves
                 Strub and Gavin Bierman",
  title =        "Gradual typing embedded securely in {JavaScript}",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "1",
  pages =        "425--437",
  month =        jan,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2578855.2535889",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Mar 4 17:04:57 MST 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "POPL '14 conference proceedings.",
  abstract =     "JavaScript's flexible semantics makes writing correct
                 code hard and writing secure code extremely difficult.
                 To address the former problem, various forms of gradual
                 typing have been proposed, such as Closure and
                 TypeScript. However, supporting all common programming
                 idioms is not easy; for example, TypeScript
                 deliberately gives up type soundness for programming
                 convenience. In this paper, we propose a gradual type
                 system and implementation techniques that provide
                 important safety and security guarantees. We present
                 TS\# , a gradual type system and source-to-source
                 compiler for JavaScript. In contrast to prior gradual
                 type systems, TS\# features full runtime reflection
                 over three kinds of types: (1) simple types for
                 higher-order functions, recursive datatypes and
                 dictionary-based extensible records; (2) the type any,
                 for dynamically type-safe TS\# expressions; and (3) the
                 type un, for untrusted, potentially malicious
                 JavaScript contexts in which TS\# is embedded. After
                 type-checking, the compiler instruments the program
                 with various checks to ensure the type safety of TS\#
                 despite its interactions with arbitrary JavaScript
                 contexts, which are free to use eval, stack walks,
                 prototype customizations, and other offensive features.
                 The proof of our main theorem employs a form of
                 type-preserving compilation, wherein we prove all the
                 runtime invariants of the translation of TS\# to
                 JavaScript by showing that translated programs are
                 well-typed in JS\# , a previously proposed dependently
                 typed language for proving functional correctness of
                 JavaScript programs. We describe a prototype compiler,
                 a secure runtime, and sample applications for TS\#. Our
                 examples illustrate how web security patterns that
                 developers currently program in JavaScript (with much
                 difficulty and still with dubious results) can instead
                 be programmed naturally in TS\#, retaining a flavor of
                 idiomatic JavaScript, while providing strong safety
                 guarantees by virtue of typing.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
}

@Article{Teyton:2014:SLM,
  author =       "C{\'e}dric Teyton and Jean-R{\'e}my Falleri and Marc
                 Palyart and Xavier Blanc",
  title =        "A study of library migrations in {Java}",
  journal =      j-J-SOFTW-EVOL-PROC,
  volume =       "26",
  number =       "11",
  pages =        "1030--1052",
  month =        nov,
  year =         "2014",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1002/smr.1660",
  ISSN =         "2047-7473 (print), 2047-7481 (electronic)",
  ISSN-L =       "2047-7473",
  bibdate =      "Wed Jan 31 13:48:30 MST 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/jsoftwevolproc.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Software: Evolution and Process",
  journal-URL =  "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)2047-7481",
}

@Article{Tosch:2014:SPA,
  author =       "Emma Tosch and Emery D. Berger",
  title =        "{SurveyMan}: programming and automatically debugging
                 surveys",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "10",
  pages =        "197--211",
  month =        oct,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2714064.2660206",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue May 12 17:41:21 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Surveys can be viewed as programs, complete with
                 logic, control flow, and bugs. Word choice or the order
                 in which questions are asked can unintentionally bias
                 responses. Vague, confusing, or intrusive questions can
                 cause respondents to abandon a survey. Surveys can also
                 have runtime errors: inattentive respondents can taint
                 results. This effect is especially problematic when
                 deploying surveys in uncontrolled settings, such as on
                 the web or via crowdsourcing platforms. Because the
                 results of surveys drive business decisions and inform
                 scientific conclusions, it is crucial to make sure they
                 are correct. We present SurveyMan, a system for
                 designing, deploying, and automatically debugging
                 surveys. Survey authors write their surveys in a
                 lightweight domain-specific language aimed at end
                 users. SurveyMan statically analyzes the survey to
                 provide feedback to survey authors before deployment.
                 It then compiles the survey into JavaScript and deploys
                 it either to the web or a crowdsourcing platform.
                 SurveyMan 's dynamic analyses automatically find survey
                 bugs, and control for the quality of responses. We
                 evaluate SurveyMan 's algorithms analytically and
                 empirically, demonstrating its effectiveness with case
                 studies of social science surveys conducted via
                 Amazon's Mechanical Turk.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '14 conference proceedings.",
}

@Article{Tu:2014:PPP,
  author =       "Chia-Heng Tu and Hui-Hsin Hsu and Jen-Hao Chen and
                 Chun-Han Chen and Shih-Hao Hung",
  title =        "Performance and power profiling for emulated {Android}
                 systems",
  journal =      j-TODAES,
  volume =       "19",
  number =       "2",
  pages =        "10:1--10:??",
  month =        mar,
  year =         "2014",
  CODEN =        "ATASFO",
  DOI =          "https://doi.org/10.1145/2566660",
  ISSN =         "1084-4309 (print), 1557-7309 (electronic)",
  ISSN-L =       "1084-4309",
  bibdate =      "Fri Mar 21 18:21:14 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/todaes/;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/todaes.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  abstract =     "Simulation is a common approach for assisting system
                 design and optimization. For system-wide optimization,
                 energy and computational resources are often the two
                 most critical issues. Monitoring the energy state of
                 each hardware component and measuring the time spent in
                 each state is needed for accurate energy and
                 performance prediction. For software optimization, it
                 is important to profile the energy and the time
                 consumed by each software construct in a realistic
                 operating environment with a proper workload. However,
                 the conventional approaches of simulation often fail to
                 produce satisfying data. First, building a
                 cycle-accurate simulation environment for a complex
                 system, such as an Android smartphone, is difficult and
                 can take a long time. Second, a slow simulation can
                 significantly alter the behavior of multithreaded,
                 I/O-intensive applications and can affect the accuracy
                 of profiles. Third, existing software-based profilers
                 generally do not work on simulators, which makes it
                 difficult for performance analysis of complicated
                 software, for example, Java applications executed by
                 the Dalvik VM in an Android system. To address these
                 aforementioned problems, we proposed and prototyped a
                 framework, called virtual performance analyzer (VPA).
                 VPA takes advantage of an existing emulator or virtual
                 machine monitor to reduce the complexity of building a
                 simulator. VPA allows the user to selectively and
                 incrementally integrate timing models and power models
                 into the emulator with our carefully designed
                 performance/power monitors, tracing facility, and
                 profiling tools to evaluate and analyze the emulated
                 system. The emulated system can perform at different
                 levels of speed to help verify if the profile data are
                 impacted by the emulation speed. Finally, VPA supports
                 existing software-based profiles and enables
                 non-intrusive tracing/profiling by minimizing the probe
                 effect. Our experimental results show that the VPA
                 framework allows users to quickly establish a
                 performance/power evaluation environment and gather
                 useful information to support system design and
                 software optimization for Android smartphones.",
  acknowledgement = ack-nhfb,
  articleno =    "10",
  fjournal =     "ACM Transactions on Design Automation of Electronic
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J776",
}

@Article{Ugawa:2014:ROP,
  author =       "Tomoharu Ugawa and Richard E. Jones and Carl G.
                 Ritson",
  title =        "Reference object processing in on-the-fly garbage
                 collection",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "11",
  pages =        "59--69",
  month =        nov,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2775049.2602991",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue May 12 17:41:19 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Most proposals for on-the-fly garbage collection
                 ignore the question of Java's weak and other reference
                 types. However, we show that reference types are
                 heavily used in DaCapo benchmarks. Of the few
                 collectors that do address this issue, most block
                 mutators, either globally or individually, while
                 processing reference types. We introduce a new
                 framework for processing reference types on-the-fly in
                 Jikes RVM. Our framework supports both insertion and
                 deletion write barriers. We have model checked our
                 algorithm and incorporated it in our new implementation
                 of the Sapphire on-the-fly collector. Using a deletion
                 barrier, we process references while mutators are
                 running in less than three times the time that previous
                 approaches take while mutators are halted; our overall
                 execution times are no worse, and often better.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "ISMM '14 conference proceedings.",
}

@Article{Vikas:2014:MGA,
  author =       "Vikas and Nasser Giacaman and Oliver Sinnen",
  title =        "Multiprocessing with {GUI}-awareness using
                 {OpenMP}-like directives in {Java}",
  journal =      j-PARALLEL-COMPUTING,
  volume =       "40",
  number =       "2",
  pages =        "69--89",
  month =        feb,
  year =         "2014",
  CODEN =        "PACOEJ",
  ISSN =         "0167-8191 (print), 1872-7336 (electronic)",
  ISSN-L =       "0167-8191",
  bibdate =      "Fri Feb 28 06:47:16 MST 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/parallelcomputing.bib;
                 https://www.math.utah.edu/pub/tex/bib/pvm.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0167819113001439",
  acknowledgement = ack-nhfb,
  fjournal =     "Parallel Computing",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01678191/",
}

@Article{Vilk:2014:DBB,
  author =       "John Vilk and Emery D. Berger",
  title =        "{Doppio}: breaking the browser language barrier",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "6",
  pages =        "508--518",
  month =        jun,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2666356.2594293",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Sep 26 07:38:28 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Web browsers have become a de facto universal
                 operating system, and JavaScript its instruction set.
                 Unfortunately, running other languages in the browser
                 is not generally possible. Translation to JavaScript is
                 not enough because browsers are a hostile environment
                 for other languages. Previous approaches are either
                 non-portable or require extensive modifications for
                 programs to work in a browser. This paper presents
                 Doppio, a JavaScript-based runtime system that makes it
                 possible to run unaltered applications written in
                 general-purpose languages directly inside the browser.
                 Doppio provides a wide range of runtime services,
                 including a file system that enables local and external
                 (cloud-based) storage, an unmanaged heap, sockets,
                 blocking I/O, and multiple threads. We demonstrate
                 DOPPIO's usefulness with two case studies: we extend
                 Emscripten with Doppio, letting it run an unmodified
                 C++ application in the browser with full functionality,
                 and present DoppioJVM, an interpreter that runs
                 unmodified JVM programs directly in the browser. While
                 substantially slower than a native JVM (between 24X and
                 42X slower on CPU-intensive benchmarks in Google
                 Chrome), DoppioJVM makes it feasible to directly reuse
                 existing, non compute-intensive code.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  received =     "PLDI '14 conference proceedings.",
}

@Article{Vitek:2014:CTR,
  author =       "Jan Vitek",
  title =        "The case for the three {R}'s of systems research:
                 repeatability, reproducibility and rigor",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "7",
  pages =        "115--116",
  month =        jul,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2674025.2576216",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Sep 26 07:29:50 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Computer systems research spans sub-disciplines that
                 include embedded systems, programming languages,
                 networking, and operating systems. In this talk my
                 contention is that a number of structural factors
                 inhibit quality systems research. Symptoms of the
                 problem include unrepeatable and unreproduced results
                 as well as results that are either devoid of meaning or
                 that measure the wrong thing. I will illustrate the
                 impact of these issues on our research output with
                 examples from the development and empirical evaluation
                 of the Schism real-time garbage collection algorithm
                 that is shipped with the FijiVM --- a Java virtual
                 machine for embedded and mobile devices. I will argue
                 that our field should foster: repetition of results,
                 independent reproduction, as well as rigorous
                 evaluation. I will outline some baby steps taken by
                 several computer conferences. In particular I will
                 focus on the introduction of Artifact Evaluation
                 Committees or AECs to ECOOP, OOPLSA, PLDI and soon
                 POPL. The goal of the AECs is to encourage author to
                 package the software artifacts that they used to
                 support the claims made in their paper and to submit
                 these artifacts for evaluation. AECs were carefully
                 designed to provide positive feedback to the authors
                 that take the time to create repeatable research.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "VEE '14 conference proceedings.",
}

@Article{Vouillon:2014:BJJ,
  author =       "J{\'e}r{\^o}me Vouillon and Vincent Balat",
  title =        "From bytecode to {JavaScript}: the {Js\_of\_ocaml}
                 compiler",
  journal =      j-SPE,
  volume =       "44",
  number =       "8",
  pages =        "951--972",
  month =        aug,
  year =         "2014",
  CODEN =        "SPEXBL",
  DOI =          "https://doi.org/10.1002/spe.2187",
  ISSN =         "0038-0644 (print), 1097-024X (electronic)",
  ISSN-L =       "0038-0644",
  bibdate =      "Wed Sep 10 05:57:37 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/spe.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Software --- Practice and Experience",
  journal-URL =  "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)1097-024X",
  onlinedate =   "26 Feb 2013",
}

@Article{Wood:2014:LLD,
  author =       "Benjamin P. Wood and Luis Ceze and Dan Grossman",
  title =        "Low-level detection of language-level data races with
                 {LARD}",
  journal =      j-COMP-ARCH-NEWS,
  volume =       "42",
  number =       "1",
  pages =        "671--686",
  month =        mar,
  year =         "2014",
  CODEN =        "CANED2",
  DOI =          "https://doi.org/10.1145/2654822.2541955",
  ISSN =         "0163-5964 (print), 1943-5851 (electronic)",
  ISSN-L =       "0163-5964",
  bibdate =      "Mon Aug 18 17:12:47 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigarch.bib",
  abstract =     "Researchers have proposed always-on data-race
                 exceptions as a way to avoid the ill effects of data
                 races, but slow performance of accurate dynamic
                 data-race detection remains a barrier to the adoption
                 of always-on data-race exceptions. Proposals for
                 accurate low-level (e.g., hardware) data-race detection
                 have the potential to reduce this performance barrier.
                 This paper explains why low-level data-race detectors
                 are wrong for programs written in high-level languages
                 (e.g., Java): they miss true data races and report
                 false data races in these programs. To bring the
                 benefits of low-level data-race detection to high-level
                 languages, we design low-level abstractable race
                 detection (LARD), an extension of the interface between
                 low-level data-race detectors and run-time systems that
                 enables accurate language-level data-race detection
                 using low-level detection mechanisms. We implement
                 accurate LARD data-race exception support for Java,
                 coupling a modified Jikes RVM Java virtual machine and
                 a simulated hardware race detector. We evaluate our
                 detector's accuracy against an accurate dynamic Java
                 data-race detector and other low-level race detectors
                 without LARD, showing that naive accurate low-level
                 data-race detectors suffer from many missed and false
                 language-level races in practice, and that LARD
                 prevents this inaccuracy.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGARCH Computer Architecture News",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J89",
  remark =       "ASPLOS '14 conference proceedings.",
}

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

@Article{Yoo:2014:WRR,
  author =       "Danny Yoo and Shriram Krishnamurthi",
  title =        "{Whalesong}: running {Racket} in the browser",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "2",
  pages =        "97--108",
  month =        feb,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2578856.2508172",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Jun 26 06:09:05 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  note =         "DLS '13 conference proceedings.",
  abstract =     "JavaScript is the language of the ubiquitous Web, but
                 it only poorly supports event-driven functional
                 programs due to its single-threaded, asynchronous
                 nature and lack of rich control flow operators. We
                 present Whalesong, a compiler from Racket that
                 generates JavaScript code that masks these problems. We
                 discuss the implementation strategy using delimited
                 continuations, an interface to the DOM, and an FFI for
                 adapting JavaScript libraries to add new
                 platform-dependent reactive features. In the process,
                 we also describe extensions to Racket's functional
                 event-driven programming model. We also briefly discuss
                 the implementation details.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "DLS '13 conference proceedings.",
}

@Article{Zakkak:2014:JJM,
  author =       "Foivos S. Zakkak and Polyvios Pratikakis",
  title =        "{JDMM}: a {Java} memory model for non-cache-coherent
                 memory architectures",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "11",
  pages =        "83--92",
  month =        nov,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2775049.2602999",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue May 12 17:41:19 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  abstract =     "As the number of cores continuously grows, processor
                 designers are considering non coherent memories as more
                 scalable and energy efficient alternatives to the
                 current coherent ones. The Java Memory Model (JMM)
                 requires that all cores can access the Java heap. It
                 guarantees sequential consistency for data-race-free
                 programs and no out-of-thin-air values for non
                 data-race-free programs. To implement the Java Memory
                 Model over non-cache-coherent and distributed
                 architectures Java Virtual Machines (JVMs) are most
                 likely to employ software caching. In this work, (i) we
                 provide a formalization of the Java Memory Model for
                 non-cache-coherent and distributed memory
                 architectures, (ii) prove the adherence of our model
                 with the Java Memory Model and (iii) evaluate,
                 regarding its compliance to the Java Memory Model, a
                 state-of-the-art Java Virtual Machine implementation on
                 a non-cache-coherent architecture.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "ISMM '14 conference proceedings.",
}

@Article{Zeyda:2014:CMS,
  author =       "Frank Zeyda and Lalkhumsanga Lalkhumsanga and Ana
                 Cavalcanti and Andy Wellings",
  title =        "Circus Models for Safety-Critical {Java} Programs",
  journal =      j-COMP-J,
  volume =       "57",
  number =       "7",
  pages =        "1046--1091",
  month =        jul,
  year =         "2014",
  CODEN =        "CMPJA6",
  DOI =          "https://doi.org/10.1093/comjnl/bxt060",
  ISSN =         "0010-4620 (print), 1460-2067 (electronic)",
  ISSN-L =       "0010-4620",
  bibdate =      "Fri Jun 20 08:41:22 MDT 2014",
  bibsource =    "http://comjnl.oxfordjournals.org/content/57/7.toc;
                 https://www.math.utah.edu/pub/tex/bib/compj2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://comjnl.oxfordjournals.org/content/57/7/1046.full.pdf+html",
  acknowledgement = ack-nhfb,
  fjournal =     "Computer Journal",
  journal-URL =  "http://comjnl.oxfordjournals.org/",
  onlinedate =   "July 3, 2013",
}

@Article{Zhang:2014:AIO,
  author =       "Wei Zhang and Per Larsen and Stefan Brunthaler and
                 Michael Franz",
  title =        "Accelerating iterators in optimizing {AST}
                 interpreters",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "10",
  pages =        "727--743",
  month =        oct,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2714064.2660223",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue May 12 17:41:21 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/python.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  abstract =     "Generators offer an elegant way to express iterators.
                 However, their performance has always been their
                 Achilles heel and has prevented widespread adoption. We
                 present techniques to efficiently implement and
                 optimize generators. We have implemented our
                 optimizations in ZipPy, a modern, light-weight AST
                 interpreter based Python 3 implementation targeting the
                 Java virtual machine. Our implementation builds on a
                 framework that optimizes AST interpreters using
                 just-in-time compilation. In such a system, it is
                 crucial that AST optimizations do not prevent
                 subsequent optimizations. Our system was carefully
                 designed to avoid this problem. We report an average
                 speedup of 3.58x for generator-bound programs. As a
                 result, using generators no longer has downsides and
                 programmers are free to enjoy their upsides.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '14 conference proceedings.",
}

@Article{Zhang:2014:ARP,
  author =       "Xin Zhang and Ravi Mangal and Radu Grigore and Mayur
                 Naik and Hongseok Yang",
  title =        "On abstraction refinement for program analyses in
                 {Datalog}",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "6",
  pages =        "239--248",
  month =        jun,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2666356.2594327",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Sep 26 07:38:28 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "A central task for a program analysis concerns how to
                 efficiently find a program abstraction that keeps only
                 information relevant for proving properties of
                 interest. We present a new approach for finding such
                 abstractions for program analyses written in Datalog.
                 Our approach is based on counterexample-guided
                 abstraction refinement: when a Datalog analysis run
                 fails using an abstraction, it seeks to generalize the
                 cause of the failure to other abstractions, and pick a
                 new abstraction that avoids a similar failure. Our
                 solution uses a boolean satisfiability formulation that
                 is general, complete, and optimal: it is independent of
                 the Datalog solver, it generalizes the failure of an
                 abstraction to as many other abstractions as possible,
                 and it identifies the cheapest refined abstraction to
                 try next. We show the performance of our approach on a
                 pointer analysis and a typestate analysis, on eight
                 real-world Java benchmark programs.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  received =     "PLDI '14 conference proceedings.",
}

@Article{Zhang:2014:HTB,
  author =       "Xin Zhang and Ravi Mangal and Mayur Naik and Hongseok
                 Yang",
  title =        "Hybrid top-down and bottom-up interprocedural
                 analysis",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "6",
  pages =        "249--258",
  month =        jun,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2666356.2594328",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Sep 26 07:38:28 MDT 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Interprocedural static analyses are broadly classified
                 into top-down and bottom-up, depending upon how they
                 compute, instantiate, and reuse procedure summaries.
                 Both kinds of analyses are challenging to scale:
                 top-down analyses are hindered by ineffective reuse of
                 summaries whereas bottom-up analyses are hindered by
                 inefficient computation and instantiation of summaries.
                 This paper presents a hybrid approach Swift that
                 combines top-down and bottom-up analyses in a manner
                 that gains their benefits without suffering their
                 drawbacks. Swift is general in that it is parametrized
                 by the top-down and bottom-up analyses it combines. We
                 show an instantiation of Swift on a type-state analysis
                 and evaluate it on a suite of 12 Java programs of size
                 60-250 KLOC each. Swift outperforms both conventional
                 approaches, finishing on all the programs while both of
                 those approaches fail on the larger programs.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  received =     "PLDI '14 conference proceedings.",
}

@Article{Zhao:2014:CSP,
  author =       "Zhijia Zhao and Bo Wu and Mingzhou Zhou and Yufei Ding
                 and Jianhua Sun and Xipeng Shen and Youfeng Wu",
  title =        "Call sequence prediction through probabilistic calling
                 automata",
  journal =      j-SIGPLAN,
  volume =       "49",
  number =       "10",
  pages =        "745--762",
  month =        oct,
  year =         "2014",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2714064.2660221",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue May 12 17:41:21 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Predicting a sequence of upcoming function calls is
                 important for optimizing programs written in modern
                 managed languages (e.g., Java, Javascript, C\#.)
                 Existing function call predictions are mainly built on
                 statistical patterns, suitable for predicting a single
                 call but not a sequence of calls. This paper presents a
                 new way to enable call sequence prediction, which
                 exploits program structures through Probabilistic
                 Calling Automata (PCA), a new program representation
                 that captures both the inherent ensuing relations among
                 function calls, and the probabilistic nature of
                 execution paths. It shows that PCA-based prediction
                 outperforms existing predictions, yielding substantial
                 speedup when being applied to guide Just-In-Time
                 compilation. By enabling accurate, efficient call
                 sequence prediction for the first time, PCA-based
                 predictors open up many new opportunities for dynamic
                 program optimizations.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '14 conference proceedings.",
}

@Article{Zschaler:2014:SJF,
  author =       "Steffen Zschaler and Birgit Demuth and Lothar
                 Schmitz",
  title =        "{Salespoint}: a {Java} framework for teaching
                 object-oriented software development",
  journal =      j-SCI-COMPUT-PROGRAM,
  volume =       "79",
  number =       "??",
  pages =        "189--203",
  day =          "1",
  month =        jan,
  year =         "2014",
  CODEN =        "SCPGD4",
  ISSN =         "0167-6423 (print), 1872-7964 (electronic)",
  ISSN-L =       "0167-6423",
  bibdate =      "Sat Nov 30 15:06:12 MST 2013",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/scicomputprogram.bib;
                 http://www.sciencedirect.com/science/journal/01676423",
  URL =          "http://www.sciencedirect.com/science/article/pii/S016764231200069X",
  acknowledgement = ack-nhfb,
  fjournal =     "Science of Computer Programming",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01676423",
}

@Article{Aigner:2015:AJE,
  author =       "Martin Aigner and Thomas H{\"u}tter and Christoph M.
                 Kirsch and Alexander Miller and Hannes Payer and Mario
                 Preishuber",
  title =        "{ACDC-JS}: explorative benchmarking of {JavaScript}
                 memory management",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "2",
  pages =        "67--78",
  month =        feb,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2775052.2661089",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue May 12 17:41:21 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  abstract =     "We present ACDC-JS, an open-source JavaScript memory
                 management benchmarking tool. ACDC-JS incorporates a
                 heap model based on real web applications and may be
                 configured to expose virtually any relevant performance
                 characteristics of JavaScript memory management
                 systems. ACDC-JS is based on ACDC, a benchmarking tool
                 for C/C++ that models periodic allocation and
                 deallocation behavior (AC) as well as persistent memory
                 (DC). We identify important characteristics of
                 JavaScript mutator behavior and propose a configurable
                 heap model based on typical distributions of these
                 characteristics as foundation for ACDC-JS. We describe
                 heap analyses of 13 real web applications extending
                 existing work on JavaScript behavior analysis. Our
                 experimental results show that ACDC-JS enables
                 performance benchmarking and debugging of
                 state-of-the-art JavaScript virtual machines such as V8
                 and SpiderMonkey by exposing key aspects of their
                 memory management performance.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "DLS '14 conference proceedings.",
}

@Article{Anikeev:2015:SGC,
  author =       "Maxim Anikeev and Felix C. Freiling and Johannes
                 G{\"o}tzfried and Tilo M{\"u}ller",
  title =        "Secure garbage collection: Preventing malicious data
                 harvesting from deallocated {Java} objects inside the
                 {Dalvik VM}",
  journal =      j-J-INFO-SEC-APPL,
  volume =       "22",
  number =       "??",
  pages =        "81--86",
  month =        jun,
  year =         "2015",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1016/j.jisa.2014.10.001",
  ISSN =         "2214-2126",
  ISSN-L =       "2214-2126",
  bibdate =      "Sun May 8 11:59:08 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/jinfosecappl.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S2214212614001367",
  acknowledgement = ack-nhfb,
  ajournal =     "J. Info. Sec. Appl.",
  fjournal =     "Journal of Information Security and Applications
                 (JISA)",
  journal-URL =  "http://www.sciencedirect.com/science/journal/22142126",
}

@Article{Anonymous:2015:BRL,
  author =       "Anonymous",
  title =        "Book Review: {{\booktitle{Learning PHP, MySQL,
                 JavaScript, CSS \& HTML5}}, by Robin Nixon. Third
                 Edition. O'Reilly. ISBN 978-1-4919-4946-7}",
  journal =      j-NETWORK-SECURITY,
  volume =       "2015",
  number =       "1",
  pages =        "4--4",
  month =        jan,
  year =         "2015",
  CODEN =        "NTSCF5",
  DOI =          "https://doi.org/10.1016/S1353-4858(15)70006-1",
  ISSN =         "1353-4858 (print), 1872-9371 (electronic)",
  ISSN-L =       "1353-4858",
  bibdate =      "Mon Dec 4 17:01:15 MST 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/network-security.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S1353485815700061",
  acknowledgement = ack-nhfb,
  fjournal =     "Network Security",
  journal-URL =  "https://www.sciencedirect.com/journal/network-security",
}

@Article{Ashrov:2015:UCB,
  author =       "Adiel Ashrov and Assaf Marron and Gera Weiss and Guy
                 Wiener",
  title =        "A use-case for behavioral programming: an architecture
                 in {JavaScript} and {Blockly} for interactive
                 applications with cross-cutting scenarios",
  journal =      j-SCI-COMPUT-PROGRAM,
  volume =       "98 (part 2)",
  number =       "??",
  pages =        "268--292",
  day =          "1",
  month =        feb,
  year =         "2015",
  CODEN =        "SCPGD4",
  ISSN =         "0167-6423 (print), 1872-7964 (electronic)",
  ISSN-L =       "0167-6423",
  bibdate =      "Thu Dec 4 19:44:58 MST 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/scicomputprogram.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S016764231400032X",
  acknowledgement = ack-nhfb,
  fjournal =     "Science of Computer Programming",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01676423/",
}

@Article{Bell:2015:VFB,
  author =       "Jonathan Bell and Eric Melski and Mohan Dattatreya and
                 Gail E. Kaiser",
  title =        "{Vroom}: Faster Build Processes for {Java}",
  journal =      j-IEEE-SOFTWARE,
  volume =       "32",
  number =       "2",
  pages =        "97--104",
  month =        mar # "\slash " # apr,
  year =         "2015",
  CODEN =        "IESOEG",
  DOI =          "https://doi.org/10.1109/MS.2015.32",
  ISSN =         "0740-7459 (print), 1937-4194 (electronic)",
  ISSN-L =       "0740-7459",
  bibdate =      "Fri Jun 5 15:23:25 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ieeesoft.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://www.computer.org/csdl/mags/so/2015/02/mso2015020097-abs.html",
  abstract-URL = "http://www.computer.org/csdl/mags/so/2015/02/mso2015020097-abs.html",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE Software",
  journal-URL =  "http://www.computer.org/portal/web/csdl/magazines/software",
  journalabr =   "IEEE Software",
}

@Article{Bogdanas:2015:KJC,
  author =       "Denis Bogdanas and Grigore Rosu",
  title =        "{K-Java}: a Complete Semantics of {Java}",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "1",
  pages =        "445--456",
  month =        jan,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2775051.2676982",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue May 12 17:41:19 MDT 2015",
  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/sigplan2010.bib",
  abstract =     "This paper presents K-Java, a complete executable
                 formal semantics of Java 1.4. K-Java was extensively
                 tested with a test suite developed alongside the
                 project, following the Test Driven Development
                 methodology. In order to maintain clarity while
                 handling the great size of Java, the semantics was
                 split into two separate definitions --- a static
                 semantics and a dynamic semantics. The output of the
                 static semantics is a preprocessed Java program, which
                 is passed as input to the dynamic semantics for
                 execution. The preprocessed program is a valid Java
                 program, which uses a subset of the features of Java.
                 The semantics is applied to model-check multi-threaded
                 programs. Both the test suite and the static semantics
                 are generic and ready to be used in other Java-related
                 projects.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "POPL '15 conference proceedings.",
}

@Article{Bouffard:2015:UCF,
  author =       "Guillaume Bouffard and Jean-Louis Lanet",
  title =        "The ultimate control flow transfer in a {Java} based
                 smart card",
  journal =      j-COMPUT-SECUR,
  volume =       "50",
  number =       "??",
  pages =        "33--46",
  month =        may,
  year =         "2015",
  CODEN =        "CPSEDU",
  ISSN =         "0167-4048 (print), 1872-6208 (electronic)",
  ISSN-L =       "0167-4048",
  bibdate =      "Mon Sep 23 09:46:41 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/computsecur2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "https://www.sciencedirect.com/science/article/pii/S016740481500005X",
  acknowledgement = ack-nhfb,
  fjournal =     "Computers \& Security",
  journal-URL =  "https://www.sciencedirect.com/science/journal/01674048",
}

@Article{Cameron:2015:JFE,
  author =       "Callum Cameron and Jeremy Singer and David Vengerov",
  title =        "The judgment of {FORSETI}: economic utility for
                 dynamic heap sizing of multiple runtimes",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "11",
  pages =        "143--156",
  month =        nov,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2887746.2754180",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Feb 16 12:01:44 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  abstract =     "We introduce the FORSETI system, which is a principled
                 approach for holistic memory management. It permits a
                 sysadmin to specify the total physical memory resource
                 that may be shared between all concurrent virtual
                 machines on a physical node. FORSETI models the heap
                 size versus application throughput for each virtual
                 machine, and seeks to maximize the combined throughput
                 of the set of VMs based on concepts from economic
                 utility theory. We evaluate the FORSETI system using a
                 standard Java managed runtime, i.e. OpenJDK. Our
                 results demonstrate that FORSETI enables dramatic
                 reductions (up to 5x) in heap footprint without
                 compromising application execution times.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "ISMM '15 conference proceedings.",
}

@Article{Ceccato:2015:LSE,
  author =       "Mariano Ceccato and Andrea Capiluppi and Paolo
                 Falcarin and Cornelia Boldyreff",
  title =        "A large study on the effect of code obfuscation on the
                 quality of {Java} code",
  journal =      j-EMPIR-SOFTWARE-ENG,
  volume =       "20",
  number =       "6",
  pages =        "1486--1524",
  month =        dec,
  year =         "2015",
  CODEN =        "ESENFW",
  DOI =          "https://doi.org/10.1007/s10664-014-9321-0",
  ISSN =         "1382-3256 (print), 1573-7616 (electronic)",
  ISSN-L =       "1382-3256",
  bibdate =      "Fri Dec 2 09:14:40 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/empir-software-eng.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://link.springer.com/accesspage/article/10.1007/s10664-014-9321-0",
  acknowledgement = ack-nhfb,
  fjournal =     "Empirical Software Engineering",
  journal-URL =  "http://link.springer.com/journal/10664",
}

@Article{Chaikalis:2015:FJS,
  author =       "T. Chaikalis and A. Chatzigeorgiou",
  title =        "Forecasting {Java} Software Evolution Trends Employing
                 Network Models",
  journal =      j-IEEE-TRANS-SOFTW-ENG,
  volume =       "41",
  number =       "6",
  pages =        "582--602",
  month =        jun,
  year =         "2015",
  CODEN =        "IESEDJ",
  DOI =          "https://doi.org/10.1109/TSE.2014.2381249",
  ISSN =         "0098-5589 (print), 1939-3520 (electronic)",
  ISSN-L =       "0098-5589",
  bibdate =      "Thu Feb 1 19:49:24 MST 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ieeetranssoftweng2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=6985636",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE Transactions on Software Engineering",
  journal-URL =  "http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=32",
}

@Article{Chatterjee:2015:QIA,
  author =       "Krishnendu Chatterjee and Andreas Pavlogiannis and
                 Yaron Velner",
  title =        "Quantitative Interprocedural Analysis",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "1",
  pages =        "539--551",
  month =        jan,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2775051.2676968",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue May 12 17:41:19 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "We consider the quantitative analysis problem for
                 interprocedural control-flow graphs (ICFGs). The input
                 consists of an ICFG, a positive weight function that
                 assigns every transition a positive integer-valued
                 number, and a labelling of the transitions (events) as
                 good, bad, and neutral events. The weight function
                 assigns to each transition a numerical value that
                 represents a measure of how good or bad an event is.
                 The quantitative analysis problem asks whether there is
                 a run of the ICFG where the ratio of the sum of the
                 numerical weights of good events versus the sum of
                 weights of bad events in the long-run is at least a
                 given threshold (or equivalently, to compute the
                 maximal ratio among all valid paths in the ICFG). The
                 quantitative analysis problem for ICFGs can be solved
                 in polynomial time, and we present an efficient and
                 practical algorithm for the problem. We show that
                 several problems relevant for static program analysis,
                 such as estimating the worst-case execution time of a
                 program or the average energy consumption of a mobile
                 application, can be modeled in our framework. We have
                 implemented our algorithm as a tool in the Java Soot
                 framework. We demonstrate the effectiveness of our
                 approach with two case studies. First, we show that our
                 framework provides a sound approach (no false
                 positives) for the analysis of inefficiently-used
                 containers. Second, we show that our approach can also
                 be used for static profiling of programs which reasons
                 about methods that are frequently invoked. Our
                 experimental results show that our tool scales to
                 relatively large benchmarks, and discovers relevant and
                 useful information that can be used to optimize
                 performance of the programs.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "POPL '15 conference proceedings.",
}

@Article{Clifford:2015:MMD,
  author =       "Daniel Clifford and Hannes Payer and Michael Stanton
                 and Ben L. Titzer",
  title =        "Memento mori: dynamic allocation-site-based
                 optimizations",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "11",
  pages =        "105--117",
  month =        nov,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2887746.2754181",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Feb 16 12:01:44 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  abstract =     "Languages that lack static typing are ubiquitous in
                 the world of mobile and web applications. The rapid
                 rise of larger applications like interactive web GUIs,
                 games, and cryptography presents a new range of
                 implementation challenges for modern virtual machines
                 to close the performance gap between typed and untyped
                 languages. While all languages can benefit from
                 efficient automatic memory management, languages like
                 JavaScript present extra thrill with innocent-looking
                 but difficult features like dynamically-sized arrays,
                 deletable properties, and prototypes. Optimizing such
                 languages requires complex dynamic techniques with more
                 radical object layout strategies such as dynamically
                 evolving representations for arrays. This paper
                 presents a general approach for gathering temporal
                 allocation site feedback that tackles both the general
                 problem of object lifetime estimation and improves
                 optimization of these problematic language features. We
                 introduce a new implementation technique where
                 allocation mementos processed by the garbage collector
                 and runtime system efficiently tie objects back to
                 allocation sites in the program and dynamically
                 estimate object lifetime, representation, and size to
                 inform three optimizations: pretenuring,
                 pretransitioning, and presizing. Unlike previous work
                 on pretenuring, our system utilizes allocation mementos
                 to achieve fully dynamic allocation-site-based
                 pretenuring in a production system. We implement all of
                 our techniques in V8, a high performance virtual
                 machine for JavaScript, and demonstrate solid
                 performance improvements across a range of
                 benchmarks.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "ISMM '15 conference proceedings.",
}

@Article{Cogumbreiro:2015:DDV,
  author =       "Tiago Cogumbreiro and Raymond Hu and Francisco Martins
                 and Nobuko Yoshida",
  title =        "Dynamic deadlock verification for general barrier
                 synchronisation",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "8",
  pages =        "150--160",
  month =        aug,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2858788.2688519",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Feb 16 12:01:42 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "We present Armus, a dynamic verification tool for
                 deadlock detection and avoidance specialised in barrier
                 synchronisation. Barriers are used to coordinate the
                 execution of groups of tasks, and serve as a building
                 block of parallel computing. Our tool verifies more
                 barrier synchronisation patterns than current
                 state-of-the-art. To improve the scalability of
                 verification, we introduce a novel event-based
                 representation of concurrency constraints, and a
                 graph-based technique for deadlock analysis. The
                 implementation is distributed and fault-tolerant, and
                 can verify X10 and Java programs. To formalise the
                 notion of barrier deadlock, we introduce a core
                 language expressive enough to represent the three most
                 widespread barrier synchronisation patterns: group,
                 split-phase, and dynamic membership. We propose a graph
                 analysis technique that selects from two alternative
                 graph representations: the Wait-For Graph, that favours
                 programs with more tasks than barriers; and the State
                 Graph, optimised for programs with more barriers than
                 tasks. We prove that finding a deadlock in either
                 representation is equivalent, and that the verification
                 algorithm is sound and complete with respect to the
                 notion of deadlock in our core language. Armus is
                 evaluated with three benchmark suites in local and
                 distributed scenarios. The benchmarks show that graph
                 analysis with automatic graph-representation selection
                 can record a 7-fold execution increase versus the
                 traditional fixed graph representation. The performance
                 measurements for distributed deadlock detection between
                 64 processes show negligible overheads.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "PPoPP '15 conference proceedings.",
}

@InCollection{deGouw:2015:OJU,
  author =       "Stijn de Gouw and Jurriaan Rot and Frank S. de Boer
                 and Richard Bubel and Reiner H{\"a}hnle",
  title =        "{OpenJDK}'s {{\tt Java.utils.Collection.sort()}} Is
                 Broken: The Good, the Bad and the Worst Case",
  crossref =     "Kroening:2015:CAV",
  pages =        "273--289",
  year =         "2015",
  DOI =          "https://doi.org/10.1007/978-3-319-21690-4_16",
  bibdate =      "Sat Jan 9 11:36:38 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://envisage-project.eu/wp-content/uploads/2015/02/sorting.pdf;
                 http://link.springer.com/chapter/10.1007/978-3-319-21690-4_16",
  abstract =     "We investigate the correctness of TimSort, which is
                 the main sorting algorithm provided by the Java
                 standard library. The goal is functional verification
                 with mechanical proofs. During our verification attempt
                 we discovered a bug which causes the implementation to
                 crash. We characterize the conditions under which the
                 bug occurs, and from this we derive a bug-free version
                 that does not compromise the performance. We formally
                 specify the new version and mechanically verify the
                 absence of this bug with KeY, a state-of-the-art
                 verification tool for Java.",
  acknowledgement = ack-nhfb,
}

@Article{Dietrich:2015:GSE,
  author =       "Jens Dietrich and Nicholas Hollingum and Bernhard
                 Scholz",
  title =        "Giga-scale exhaustive points-to analysis for {Java} in
                 under a minute",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "10",
  pages =        "535--551",
  month =        oct,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2858965.2814307",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Feb 16 12:01:43 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Computing a precise points-to analysis for very large
                 Java programs remains challenging despite the large
                 body of research on points-to analysis. Any approach
                 must solve an underlying dynamic graph reachability
                 problem, for which the best algorithms have near-cubic
                 worst-case runtime complexity, and, hence, previous
                 work does not scale to programs with millions of lines
                 of code. In this work, we present a novel approach for
                 solving the field-sensitive points-to problem for Java
                 with the means of (1) a transitive-closure
                 data-structure, and (2) a pre-computed set of
                 potentially matching load/store pairs to accelerate the
                 fix-point calculation. Experimentation on Java
                 benchmarks validates the superior performance of our
                 approach over the standard context-free language
                 reachability implementations. Our approach computes a
                 points-to index for the OpenJDK with over 1.5 billion
                 tuples in under a minute.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '15 conference proceedings.",
}

@Article{Disney:2015:SYJ,
  author =       "Tim Disney and Nathan Faubion and David Herman and
                 Cormac Flanagan",
  title =        "Sweeten your {JavaScript}: hygienic macros for {ES5}",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "2",
  pages =        "35--44",
  month =        feb,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2775052.2661097",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue May 12 17:41:21 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Lisp and Scheme have demonstrated the power of macros
                 to enable programmers to evolve and craft languages. In
                 languages with more complex syntax, macros have had
                 less success. In part, this has been due to the
                 difficulty in building expressive hygienic macro
                 systems for such languages. JavaScript in particular
                 presents unique challenges for macro systems due to
                 ambiguities in the lexing stage that force the
                 JavaScript lexer and parser to be intertwined. In this
                 paper we present a novel solution to the lexing
                 ambiguity of JavaScript that enables us to cleanly
                 separate the JavaScript lexer and parser by recording
                 enough history during lexing to resolve ambiguities. We
                 give an algorithm for this solution along with a proof
                 that it does in fact correctly resolve ambiguities in
                 the language. Though the algorithm and proof we present
                 is specific to JavaScript, the general technique can be
                 applied to other languages with ambiguous grammars.
                 With lexer and parser separated, we then implement an
                 expressive hygienic macro system for JavaScript called
                 sweet.js.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "DLS '14 conference proceedings.",
}

@Article{Ebert:2015:ESE,
  author =       "Felipe Ebert and Fernando Castor and Alexander
                 Serebrenik",
  title =        "An exploratory study on exception handling bugs in
                 {Java} programs",
  journal =      j-J-SYST-SOFTW,
  volume =       "106",
  number =       "??",
  pages =        "82--101",
  month =        aug,
  year =         "2015",
  CODEN =        "JSSODM",
  ISSN =         "0164-1212 (print), 1873-1228 (electronic)",
  ISSN-L =       "0164-1212",
  bibdate =      "Mon Jun 8 11:23:23 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/jsystsoftw.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0164121215000862",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Systems and Software",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01641212/",
}

@Article{Erdweg:2015:SOI,
  author =       "Sebastian Erdweg and Moritz Lichter and Manuel Weiel",
  title =        "A sound and optimal incremental build system with
                 dynamic dependencies",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "10",
  pages =        "89--106",
  month =        oct,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2858965.2814316",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Feb 16 12:01:43 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Build systems are used in all but the smallest
                 software projects to invoke the right build tools on
                 the right files in the right order. A build system must
                 be sound (after a build, generated files consistently
                 reflect the latest source files) and efficient (recheck
                 and rebuild as few build units as possible).
                 Contemporary build systems provide limited efficiency
                 because they lack support for expressing fine-grained
                 file dependencies. We present a build system called
                 pluto that supports the definition of reusable,
                 parameterized, interconnected builders. When run, a
                 builder notifies the build system about dynamically
                 required and produced files as well as about other
                 builders whose results are needed. To support
                 fine-grained file dependencies, we generalize the
                 traditional notion of time stamps to allow builders to
                 declare their actual requirements on a file's content.
                 pluto collects the requirements and products of a
                 builder with their stamps in a build summary. This
                 enables pluto to provides provably sound and optimal
                 incremental rebuilding. To support dynamic
                 dependencies, our rebuild algorithm interleaves
                 dependency analysis and builder execution and enforces
                 invariants on the dependency graph through a dynamic
                 analysis. We have developed pluto as a Java API and
                 used it to implement more than 25 builders. We describe
                 our experience with migrating a larger Ant build script
                 to pluto and compare the respective build times.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '15 conference proceedings.",
}

@Article{Exposito:2015:LLJ,
  author =       "Roberto R. Exp{\'o}sito and Guillermo L. Taboada and
                 Sabela Ramos and Juan Touri{\~n}o and Ram{\'o}n
                 Doallo",
  title =        "Low-latency {Java} communication devices on
                 {RDMA}-enabled networks",
  journal =      j-CCPE,
  volume =       "27",
  number =       "17",
  pages =        "4852--4879",
  day =          "10",
  month =        dec,
  year =         "2015",
  CODEN =        "CCPEBO",
  DOI =          "https://doi.org/10.1002/cpe.3473",
  ISSN =         "1532-0626 (print), 1532-0634 (electronic)",
  ISSN-L =       "1532-0626",
  bibdate =      "Tue Feb 9 06:13:20 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Concurrency and Computation: Practice and Experience",
  journal-URL =  "http://www.interscience.wiley.com/jpages/1532-0626",
  onlinedate =   "15 May 2015",
}

@Article{Fan:2015:UCC,
  author =       "Hua Fan and Aditya Ramaraju and Marlon McKenzie and
                 Wojciech Golab and Bernard Wong",
  title =        "Understanding the causes of consistency anomalies in
                 {Apache Cassandra}",
  journal =      j-PROC-VLDB-ENDOWMENT,
  volume =       "8",
  number =       "7",
  pages =        "810--813",
  month =        feb,
  year =         "2015",
  CODEN =        "????",
  ISSN =         "2150-8097",
  bibdate =      "Wed Apr 15 19:04:24 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib;
                 https://www.math.utah.edu/pub/tex/bib/vldbe.bib",
  abstract =     "A recent paper on benchmarking eventual consistency
                 showed that when a constant workload is applied against
                 Cassandra, the staleness of values returned by read
                 operations exhibits interesting but unexplained
                 variations when plotted against time. In this paper we
                 reproduce this phenomenon and investigate in greater
                 depth the low-level mechanisms that give rise to stale
                 reads. We show that the staleness spikes exhibited by
                 Cassandra are strongly correlated with garbage
                 collection, particularly the ``stop-the-world'' phase
                 which pauses all application threads in a Java virtual
                 machine. We show experimentally that the staleness
                 spikes can be virtually eliminated by delaying read
                 operations artificially at servers immediately after a
                 garbage collection pause. In our experiments this
                 yields more than a 98\% reduction in the number of
                 consistency anomalies that exceed 5ms, and has
                 negligible impact on throughput and latency.",
  acknowledgement = ack-nhfb,
  fjournal =     "Proceedings of the VLDB Endowment",
  journal-URL =  "http://portal.acm.org/citation.cfm?id=J1174",
}

@Article{Felgentreff:2015:CBC,
  author =       "Tim Felgentreff and Todd Millstein and Alan Borning
                 and Robert Hirschfeld",
  title =        "Checks and balances: constraint solving without
                 surprises in object-constraint programming languages",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "10",
  pages =        "767--782",
  month =        oct,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2858965.2814311",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Feb 16 12:01:43 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Object-constraint programming systems integrate
                 declarative constraint solving with imperative,
                 object-oriented languages, seamlessly providing the
                 power of both paradigms. However, experience with
                 object-constraint systems has shown that giving too
                 much power to the constraint solver opens up the
                 potential for solutions that are surprising and
                 unintended as well as for complex interactions between
                 constraints and imperative code. On the other hand,
                 systems that overly limit the power of the solver, for
                 example by disallowing constraints involving mutable
                 objects, object identity, or polymorphic message sends,
                 run the risk of excluding the core object-oriented
                 features of the language from the constraint part, and
                 consequently not being able to express declaratively a
                 large set of interesting problem solutions. In this
                 paper we present design principles that tame the power
                 of the constraint solver in object-constraint languages
                 to avoid difficult corner cases and surprising
                 solutions while retaining the key features of the
                 approach, including constraints over mutable objects,
                 constraints involving object identity, and constraints
                 on the results of message sends. We present our
                 solution concretely in the context of the Babelsberg
                 object-constraint language framework, providing both an
                 informal description of the resulting language and a
                 formal semantics for a core subset of it. We validate
                 the utility of this semantics with an executable
                 version that allows us to run test programs and to
                 verify that they provide the same results as existing
                 implementations of Babelsberg in JavaScript, Ruby, and
                 Smalltalk.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '15 conference proceedings.",
}

@Article{Feng:2015:EQD,
  author =       "Yu Feng and Xinyu Wang and Isil Dillig and Calvin
                 Lin",
  title =        "{EXPLORER}: query- and demand-driven exploration of
                 interprocedural control flow properties",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "10",
  pages =        "520--534",
  month =        oct,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2858965.2814284",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Feb 16 12:01:43 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "This paper describes a general framework and its
                 implementation in a tool called EXPLORER for statically
                 answering a class of interprocedural control flow
                 queries about Java programs. EXPLORER allows users to
                 formulate queries about feasible callstack
                 configurations using regular expressions, and it
                 employs a precise, demand-driven algorithm for
                 answering such queries. Specifically, EXPLORER
                 constructs an automaton A that is iteratively refined
                 until either the language accepted by A is empty
                 (meaning that the query has been refuted) or until no
                 further refinement is possible based on a precise,
                 context-sensitive abstraction of the program. We
                 evaluate EXPLORER by applying it to three different
                 program analysis tasks, namely, (1) analysis of the
                 observer design pattern in Java, (2) identification of
                 a class of performance bugs, and (3) analysis of
                 inter-component communication in Android applications.
                 Our evaluation shows that EXPLORER is both efficient
                 and precise.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '15 conference proceedings.",
}

@Article{Freudenberg:2015:SMP,
  author =       "Bert Freudenberg and Dan H. H. Ingalls and Tim
                 Felgentreff and Tobias Pape and Robert Hirschfeld",
  title =        "{SqueakJS}: a modern and practical smalltalk that runs
                 in any browser",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "2",
  pages =        "57--66",
  month =        feb,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2775052.2661100",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue May 12 17:41:21 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  abstract =     "We report our experience in implementing SqueakJS, a
                 bit-compatible implementation of Squeak/Smalltalk
                 written in pure JavaScript. SqueakJS runs entirely in
                 the Web browser with a virtual filesystem that can be
                 directed to a server or client-side storage. Our
                 implementation is notable for simplicity and
                 performance gained through adaptation to the host
                 object memory and deployment leverage gained through
                 the Lively Web development environment. We present
                 several novel techniques as well as performance
                 measurements for the resulting virtual machine. Much of
                 this experience is potentially relevant to preserving
                 other dynamic language systems and making them
                 available in a browser-based environment.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "DLS '14 conference proceedings.",
}

@Article{Gidra:2015:NGC,
  author =       "Lokesh Gidra and Ga{\"e}l Thomas and Julien Sopena and
                 Marc Shapiro and Nhan Nguyen",
  title =        "{NumaGiC}: a Garbage Collector for Big Data on Big
                 {NUMA} Machines",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "4",
  pages =        "661--673",
  month =        apr,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2775054.2694361",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue May 12 17:41:19 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  abstract =     "On contemporary cache-coherent Non-Uniform Memory
                 Access (ccNUMA) architectures, applications with a
                 large memory footprint suffer from the cost of the
                 garbage collector (GC), because, as the GC scans the
                 reference graph, it makes many remote memory accesses,
                 saturating the interconnect between memory nodes. We
                 address this problem with NumaGiC, a GC with a
                 mostly-distributed design. In order to maximise memory
                 access locality during collection, a GC thread avoids
                 accessing a different memory node, instead notifying a
                 remote GC thread with a message; nonetheless, NumaGiC
                 avoids the drawbacks of a pure distributed design,
                 which tends to decrease parallelism. We compare NumaGiC
                 with Parallel Scavenge and NAPS on two different ccNUMA
                 architectures running on the Hotspot Java Virtual
                 Machine of OpenJDK 7. On Spark and Neo4j, two
                 industry-strength analytics applications, with heap
                 sizes ranging from 160GB to 350GB, and on SPECjbb2013
                 and SPECjbb2005, our gc improves overall performance by
                 up to 45\% over NAPS (up to 94\% over Parallel
                 Scavenge), and increases the performance of the
                 collector itself by up to 3.6x over NAPS (up to 5.4x
                 over Parallel Scavenge).",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "ASPLOS '15 conference proceedings.",
}

@Article{Gill:2015:RMD,
  author =       "Andy Gill and Neil Sculthorpe and Justin Dawson and
                 Aleksander Eskilson and Andrew Farmer and Mark Grebe
                 and Jeffrey Rosenbluth and Ryan Scott and James
                 Stanton",
  title =        "The remote monad design pattern",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "12",
  pages =        "59--70",
  month =        dec,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2887747.2804311",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Feb 16 12:01:44 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Remote Procedure Calls are expensive. This paper
                 demonstrates how to reduce the cost of calling remote
                 procedures from Haskell by using the remote monad
                 design pattern, which amortizes the cost of remote
                 calls. This gives the Haskell community access to
                 remote capabilities that are not directly supported, at
                 a surprisingly inexpensive cost. We explore the remote
                 monad design pattern through six models of remote
                 execution patterns, using a simulated Internet of
                 Things toaster as a running example. We consider the
                 expressiveness and optimizations enabled by each remote
                 execution model, and assess the feasibility of our
                 approach. We then present a full-scale case study: a
                 Haskell library that provides a Foreign Function
                 Interface to the JavaScript Canvas API. Finally, we
                 discuss existing instances of the remote monad design
                 pattern found in Haskell libraries.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "Haskell '15 conference proceedings.",
}

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

@Article{Golan-Gueta:2015:ASA,
  author =       "Guy Golan-Gueta and G. Ramalingam and Mooly Sagiv and
                 Eran Yahav",
  title =        "Automatic scalable atomicity via semantic locking",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "8",
  pages =        "31--41",
  month =        aug,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2858788.2688511",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Feb 16 12:01:42 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "In this paper, we consider concurrent programs in
                 which the shared state consists of instances of
                 linearizable ADTs (abstract data types). We present an
                 automated approach to concurrency control that
                 addresses a common need: the need to atomically execute
                 a code fragment, which may contain multiple ADT
                 operations on multiple ADT instances. We present a
                 synthesis algorithm that automatically enforces
                 atomicity of given code fragments (in a client program)
                 by inserting pessimistic synchronization that
                 guarantees atomicity and deadlock-freedom (without
                 using any rollback mechanism). Our algorithm takes a
                 commutativity specification as an extra input. This
                 specification indicates for every pair of ADT
                 operations the conditions under which the operations
                 commute. Our algorithm enables greater parallelism by
                 permitting commuting operations to execute
                 concurrently. We have implemented the synthesis
                 algorithm in a Java compiler, and applied it to several
                 Java programs. Our results show that our approach
                 produces efficient and scalable synchronization.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "PPoPP '15 conference proceedings.",
}

@Article{Gramoli:2015:MTY,
  author =       "Vincent Gramoli",
  title =        "More than you ever wanted to know about
                 synchronization: synchrobench, measuring the impact of
                 the synchronization on concurrent algorithms",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "8",
  pages =        "1--10",
  month =        aug,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2858788.2688501",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Feb 16 12:01:42 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "In this paper, we present the most extensive
                 comparison of synchronization techniques. We evaluate 5
                 different synchronization techniques through a series
                 of 31 data structure algorithms from the recent
                 literature on 3 multicore platforms from Intel, Sun
                 Microsystems and AMD. To this end, we developed in
                 C/C++ and Java a new micro-benchmark suite, called
                 Synchrobench, hence helping the community evaluate new
                 data structures and synchronization techniques. The
                 main conclusion of this evaluation is threefold: (i)
                 although compare-and-swap helps achieving the best
                 performance on multicores, doing so correctly is hard;
                 (ii) optimistic locking offers varying performance
                 results while transactional memory offers more
                 consistent results; and (iii) copy-on-write and
                 read-copy-update suffer more from contention than any
                 other technique but could be combined with others to
                 derive efficient algorithms.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "PPoPP '15 conference proceedings.",
}

@Article{Gvero:2015:SJE,
  author =       "Tihomir Gvero and Viktor Kuncak",
  title =        "Synthesizing {Java} expressions from free-form
                 queries",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "10",
  pages =        "416--432",
  month =        oct,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2858965.2814295",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Feb 16 12:01:43 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "We present a new code assistance tool for integrated
                 development environments. Our system accepts as input
                 free-form queries containing a mixture of English and
                 Java, and produces Java code expressions that take the
                 query into account and respect syntax, types, and
                 scoping rules of Java, as well as statistical usage
                 patterns. In contrast to solutions based on code
                 search, the results returned by our tool need not
                 directly correspond to any previously seen code
                 fragment. As part of our system we have constructed a
                 probabilistic context free grammar for Java constructs
                 and library invocations, as well as an algorithm that
                 uses a customized natural language processing tool
                 chain to extract information from free-form text
                 queries. We present the results on a number of examples
                 showing that our technique (1) often produces the
                 expected code fragments, (2) tolerates much of the
                 flexibility of natural language, and (3) can repair
                 incorrect Java expressions that use, for example, the
                 wrong syntax or missing arguments.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '15 conference proceedings.",
}

@Article{Hague:2015:DRC,
  author =       "Matthew Hague and Anthony W. Lin and C.-H. Luke Ong",
  title =        "Detecting redundant {CSS} rules in {HTML5}
                 applications: a tree rewriting approach",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "10",
  pages =        "1--19",
  month =        oct,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2858965.2814288",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Feb 16 12:01:43 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "HTML5 applications normally have a large set of CSS
                 (Cascading Style Sheets) rules for data display. Each
                 CSS rule consists of a node selector and a declaration
                 block (which assigns values to selected nodes' display
                 attributes). As web applications evolve, maintaining
                 CSS files can easily become problematic. Some CSS rules
                 will be replaced by new ones, but these obsolete (hence
                 redundant) CSS rules often remain in the applications.
                 Not only does this ``bloat'' the applications ---
                 increasing the bandwidth requirement --- but it also
                 significantly increases web browsers' processing time.
                 Most works on detecting redundant CSS rules in HTML5
                 applications do not consider the dynamic behaviours of
                 HTML5 (specified in JavaScript); in fact, the only
                 proposed method that takes these into account is
                 dynamic analysis, which cannot soundly prove redundancy
                 of CSS rules. In this paper, we introduce an
                 abstraction of HTML5 applications based on monotonic
                 tree-rewriting and study its ``redundancy problem''. We
                 establish the precise complexity of the problem and
                 various subproblems of practical importance (ranging
                 from P to EXP). In particular, our algorithm relies on
                 an efficient reduction to an analysis of symbolic
                 pushdown systems (for which highly optimised solvers
                 are available), which yields a fast method for checking
                 redundancy in practice. We implemented our algorithm
                 and demonstrated its efficacy in detecting redundant
                 CSS rules in HTML5 applications.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '15 conference proceedings.",
}

@Article{Hanenberg:2015:WDW,
  author =       "Stefan Hanenberg",
  title =        "Why do we know so little about programming languages,
                 and what would have happened if we had known more?",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "2",
  pages =        "1--1",
  month =        feb,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2775052.2661102",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue May 12 17:41:21 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Programming language research in the last decades was
                 mainly driven by mathematical methods (such as formal
                 semantics, correctness proofs, type soundness proofs,
                 etc.) or run-time arguments based on benchmark tests.
                 This happened despite the frequent discussion over
                 programming language usability. We have now been
                 through decade after decade of one language after
                 another dominating the field, forcing companies to
                 switch languages and migrate libraries. Now that
                 Javascript seems to be the next language to dominate,
                 people start to ask old questions anew. The first goal
                 of this talk is to discuss why the application of
                 empirical methods is (still) relatively rare in PL
                 research, and to discuss what could be done in
                 empirical methods to make them a substantial part of PL
                 research. The second goal is to speculate about the
                 possible effects that concrete empirical knowledge
                 could have had on the programming language community.
                 For example, what would have happened to programming
                 languages if current knowledge would have been
                 available 30 years ago? What if knowledge about
                 programming languages from the year 2050 would be
                 available today?",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "DLS '14 conference proceedings.",
}

@Article{Humer:2015:DSL,
  author =       "Christian Humer and Christian Wimmer and Christian
                 Wirth and Andreas W{\"o}{\ss} and Thomas
                 W{\"u}rthinger",
  title =        "A domain-specific language for building
                 self-optimizing {AST} interpreters",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "3",
  pages =        "123--132",
  month =        mar,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2775053.2658776",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue May 12 17:41:23 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/python.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Self-optimizing AST interpreters dynamically adapt to
                 the provided input for faster execution. This
                 adaptation includes initial tests of the input, changes
                 to AST nodes, and insertion of guards that ensure
                 assumptions still hold. Such specialization and
                 speculation is essential for the performance of dynamic
                 programming languages such as JavaScript. In
                 traditional procedural and objectoriented programming
                 languages it can be tedious to write selfoptimizing AST
                 interpreters, as those languages fail to provide
                 constructs that would specifically support that. This
                 paper introduces a declarative domain-specific language
                 (DSL) that greatly simplifies writing self-optimizing
                 AST interpreters. The DSL supports specialization of
                 operations based on types of the input and other
                 properties. It can then use these specializations
                 directly or chain them to represent the operation with
                 the minimum amount of code possible. The DSL
                 significantly reduces the complexity of expressing
                 specializations for those interpreters. We use it in
                 our high-performance implementation of JavaScript,
                 where 274 language operations have an average of about
                 4 and a maximum of 190 specializations. In addition,
                 the DSL is used in implementations of Ruby, Python, R,
                 and Smalltalk.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "GPCE '14 conference proceedings.",
}

@Article{Johnson:2015:EES,
  author =       "Andrew Johnson and Lucas Waye and Scott Moore and
                 Stephen Chong",
  title =        "Exploring and enforcing security guarantees via
                 program dependence graphs",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "6",
  pages =        "291--302",
  month =        jun,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2813885.2737957",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Feb 16 12:01:41 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "We present PIDGIN, a program analysis and
                 understanding tool that enables the specification and
                 enforcement of precise application-specific information
                 security guarantees. PIDGIN also allows developers to
                 interactively explore the information flows in their
                 applications to develop policies and investigate
                 counter-examples. PIDGIN combines program dependence
                 graphs (PDGs), which precisely capture the information
                 flows in a whole application, with a custom PDG query
                 language. Queries express properties about the paths in
                 the PDG; because paths in the PDG correspond to
                 information flows in the application, queries can be
                 used to specify global security policies. PIDGIN is
                 scalable. Generating a PDG for a 330k line Java
                 application takes 90 seconds, and checking a policy on
                 that PDG takes under 14 seconds. The query language is
                 expressive, supporting a large class of precise,
                 application-specific security guarantees. Policies are
                 separate from the code and do not interfere with
                 testing or development, and can be used for security
                 regression testing. We describe the design and
                 implementation of PIDGIN and report on using it: (1) to
                 explore information security guarantees in legacy
                 programs; (2) to develop and modify security policies
                 concurrently with application development; and (3) to
                 develop policies based on known vulnerabilities.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "PLDI '15 conference proceedings.",
}

@Article{Karakoidas:2015:TSE,
  author =       "Vassilios Karakoidas and Dimitris Mitropoulos and
                 Panagiotis Louridas and Diomidis Spinellis",
  title =        "A type-safe embedding of {SQL} into {Java} using the
                 extensible compiler framework {J\%}",
  journal =      j-COMP-LANGS-SYS-STRUCT,
  volume =       "41",
  number =       "??",
  pages =        "1--20",
  month =        apr,
  year =         "2015",
  CODEN =        "????",
  ISSN =         "1477-8424 (print), 1873-6866 (electronic)",
  ISSN-L =       "1477-8424",
  bibdate =      "Fri Apr 17 08:28:13 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/complngs.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S1477842415000020",
  acknowledgement = ack-nhfb,
  fjournal =     "Computer Languages, Systems and Structures",
  journal-URL =  "http://www.sciencedirect.com/science/journal/14778424/",
}

@Article{Keil:2015:BAH,
  author =       "Matthias Keil and Peter Thiemann",
  title =        "Blame assignment for higher-order contracts with
                 intersection and union",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "9",
  pages =        "375--386",
  month =        sep,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2858949.2784737",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Feb 16 12:01:43 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "We present an untyped calculus of blame assignment for
                 a higher-order contract system with two new operators:
                 intersection and union. The specification of these
                 operators is based on the corresponding type theoretic
                 constructions. This connection makes intersection and
                 union contracts their inevitable dynamic counterparts
                 with a range of desirable properties and makes them
                 suitable for subsequent integration in a gradual type
                 system. A denotational specification provides the
                 semantics of a contract in terms of two sets: a set of
                 terms satisfying the contract and a set of contexts
                 respecting the contract. This kind of specification for
                 contracts is novel and interesting in its own right. A
                 nondeterministic operational semantics serves as the
                 specification for contract monitoring and for proving
                 its correctness. It is complemented by a deterministic
                 semantics that is closer to an implementation and that
                 is connected to the nondeterministic semantics by
                 simulation. The calculus is the formal basis of TJS, a
                 language embedded, higher-order contract system
                 implemented for JavaScript.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "ICFP '15 conference proceedings.",
}

@Article{Kereki:2015:JAW,
  author =       "Federico Kereki",
  title =        "{JavaScript} all the way down",
  journal =      j-LINUX-J,
  volume =       "2015",
  number =       "250",
  pages =        "1:1--1:??",
  month =        feb,
  year =         "2015",
  CODEN =        "LIJOFX",
  ISSN =         "1075-3583 (print), 1938-3827 (electronic)",
  ISSN-L =       "1075-3583",
  bibdate =      "Thu Apr 2 16:27:43 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/linux-journal.bib",
  URL =          "http://dl.acm.org/ft_gateway.cfm?id=2754898",
  abstract =     "JavaScript for server- and client-side Web
                 development.",
  acknowledgement = ack-nhfb,
  articleno =    "1",
  fjournal =     "Linux Journal",
  journal-URL =  "http://portal.acm.org/citation.cfm?id=J508",
}

@Article{Khan:2015:UJW,
  author =       "Faiz Khan and Vincent Foley-Bourgon and Sujay
                 Kathrotia and Erick Lavoie and Laurie Hendren",
  title =        "Using {JavaScript} and {WebCL} for numerical
                 computations: a comparative study of native and web
                 technologies",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "2",
  pages =        "91--102",
  month =        feb,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2775052.2661090",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue May 12 17:41:21 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "From its modest beginnings as a tool to validate
                 forms, JavaScript is now an industrial-strength
                 language used to power online applications such as
                 spreadsheets, IDEs, image editors and even 3D games.
                 Since all modern web browsers support JavaScript, it
                 provides a medium that is both easy to distribute for
                 developers and easy to access for users. This paper
                 provides empirical data to answer the question: Is
                 JavaScript fast enough for numerical computations? By
                 measuring and comparing the runtime performance of
                 benchmarks representative of a wide variety of
                 scientific applications, we show that sequential
                 JavaScript is within a factor of 2 of native code.
                 Parallel code using WebCL shows speed improvements of
                 up to 2.28 over JavaScript for the majority of the
                 benchmarks.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "DLS '14 conference proceedings.",
}

@Article{Kroshko:2015:OPN,
  author =       "Andrew Kroshko and Raymond J. Spiteri",
  title =        "{odeToJava}: a {PSE} for the Numerical Solution of
                 {IVPs}",
  journal =      j-TOMS,
  volume =       "41",
  number =       "3",
  pages =        "17:1--17:33",
  month =        jun,
  year =         "2015",
  CODEN =        "ACMSCU",
  DOI =          "https://doi.org/10.1145/2641563",
  ISSN =         "0098-3500 (print), 1557-7295 (electronic)",
  ISSN-L =       "0098-3500",
  bibdate =      "Wed Jun 3 17:59:32 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/toms.bib",
  abstract =     "Problem-solving environments (PSEs) offer a powerful
                 yet flexible and convenient means for general
                 experimentation with computational methods, algorithm
                 prototyping, and visualization and manipulation of
                 data. Consequently, PSEs have become the modus operandi
                 of many computational scientists and engineers.
                 However, despite these positive aspects, PSEs typically
                 do not offer the level of granularity required by the
                 specialist or algorithm designer to conveniently modify
                 the details. In other words, the level at which PSEs
                 are black boxes is often still too high for someone
                 interested in modifying an algorithm as opposed to
                 trying an alternative. In this article, we describe
                 odeToJava, a Java-based PSE for initial-value problems
                 in ordinary differential equations. odeToJava
                 implements explicit and linearly implicit
                 implicit-explicit Runge--Kutta methods with error and
                 stepsize control and intra-step interpolation (dense
                 output), giving the user control and flexibility over
                 the implementational aspects of these methods. We
                 illustrate the usage and functionality of odeToJava by
                 means of computational case studies of initial-value
                 problems (IVPs).",
  acknowledgement = ack-nhfb,
  articleno =    "17",
  fjournal =     "ACM Transactions on Mathematical Software (TOMS)",
  journal-URL =  "http://dl.acm.org/pub.cfm?id=J782",
}

@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/java2010.bib;
                 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,
  articleno =    "13",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Leino:2015:APS,
  author =       "K. Rustan M. Leino and Paqui Lucio",
  title =        "An Assertional Proof of the Stability and Correctness
                 of {Natural Mergesort}",
  journal =      j-TOCL,
  volume =       "17",
  number =       "1",
  pages =        "6:1--6:22",
  month =        dec,
  year =         "2015",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/2814571",
  ISSN =         "1529-3785 (print), 1557-945X (electronic)",
  ISSN-L =       "1529-3785",
  bibdate =      "Sat Jan 9 10:42:43 MST 2016",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tocl/;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/tocl.bib",
  abstract =     "We present a mechanically verified implementation of
                 the sorting algorithm Natural Mergesort that consists
                 of a few methods specified by their contracts of
                 pre/post conditions. Methods are annotated with
                 assertions that allow the automatic verification of the
                 contract satisfaction. This program-proof is made using
                 the state-of-the-art verifier Dafny. We verify not only
                 the standard sortedness property, but also that the
                 algorithm performs a stable sort. Throughout the
                 article, we provide and explain the complete text of
                 the program-proof.",
  acknowledgement = ack-nhfb,
  articleno =    "6",
  fjournal =     "ACM Transactions on Computational Logic",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J773",
  remark =       "From the conclusion on pages 20--21: ``There is no
                 doubt that sorting algorithms are useful and important
                 in software. Good algorithms based on ingenious ideas
                 can be subtle and warrant formal proofs. Indeed, if the
                 comparison {\tt GT(min,xs.head)} in function {\tt
                 descending} were replaced by {\tt $ \neg
                 $GT(xs.head,min)}, then the algorithm would no longer
                 be stable. An excellent example is the recent
                 revelation [de Gouw et al. 2015] of the incorrectness
                 of a very popular sorting algorithm that has been
                 running since 2002 in billions of computers, cloud
                 services, and mobile phones. Indeed, it is the default
                 sorting algorithm for Android SDK, Sun's JDK, and
                 OpenJDK. The bug was discovered and fixed using the
                 formal verification tool KeY [Beckert et al. 2007]. The
                 bug appeared already in the original implementation in
                 Python.'' The 2015 reference is ``Stijn de Gouw,
                 Jurriaan Rot, Frank S. de Boer, Richard Bubel, and
                 Reiner H{\"a}hnle. 2015. \booktitle{OpenJDK's {\tt
                 java.utils.Collection.sort()} is broken: The good, the
                 bad and the worst case}. In \booktitle{Computer Aided
                 Verification. 27th International Conference, CAV 2015}
                 (LNCS). Springer. doi:10.1007/978-3-319-21690-4_16.''",
}

@Article{Lin:2015:SGU,
  author =       "Yi Lin and Kunshan Wang and Stephen M. Blackburn and
                 Antony L. Hosking and Michael Norrish",
  title =        "Stop and go: understanding yieldpoint behavior",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "11",
  pages =        "70--80",
  month =        nov,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2887746.2754187",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Feb 16 12:01:44 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Yieldpoints are critical to the implementation of high
                 performance garbage collected languages, yet the design
                 space is not well understood. Yieldpoints allow a
                 running program to be interrupted at well-defined
                 points in its execution, facilitating exact garbage
                 collection, biased locking, on-stack replacement,
                 profiling, and other important virtual machine
                 behaviors. In this paper we identify and evaluate
                 yieldpoint design choices, including previously
                 undocumented designs and optimizations. One of the
                 designs we identify opens new opportunities for very
                 low overhead profiling. We measure the frequency with
                 which yieldpoints are executed and establish a
                 methodology for evaluating the common case execution
                 time overhead. We also measure the median and worst
                 case time-to-yield. We find that Java benchmarks
                 execute about 100M yieldpoints per second, of which
                 about 1/20000 are taken. The average execution time
                 overhead for untaken yieldpoints on the VM we use
                 ranges from 2.5\% to close to zero on modern hardware,
                 depending on the design, and we find that the designs
                 trade off total overhead with worst case time-to-yield.
                 This analysis gives new insight into a critical but
                 overlooked aspect of garbage collector implementation,
                 and identifies a new optimization and new opportunities
                 for very low overhead profiling.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "ISMM '15 conference proceedings.",
}

@Article{Lin:2015:STU,
  author =       "Yixiao Lin and Sayan Mitra",
  title =        "{StarL}: Towards a Unified Framework for Programming,
                 Simulating and Verifying Distributed Robotic Systems",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "5",
  pages =        "9:1--9:??",
  month =        may,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2808704.2754966",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Jul 31 19:39:44 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "We developed StarL as a framework for programming,
                 simulating, and verifying distributed systems that
                 interacts with physical processes. StarL framework has
                 (a) a collection of distributed primitives for
                 coordination, such as mutual exclusion, registration
                 and geocast that can be used to build sophisticated
                 applications, (b) theory libraries for verifying StarL
                 applications in the PVS theorem prover, and (c) an
                 execution environment that can be used to deploy the
                 applications on hardware or to execute them in a
                 discrete event simulator. The primitives have (i)
                 abstract, nondeterministic specifications in terms of
                 invariants, and assume-guarantee style progress
                 properties, (ii) implementations in Java/Android that
                 always satisfy the invariants and attempt progress
                 using best effort strategies. The PVS theories specify
                 the invariant and progress properties of the
                 primitives, and have to be appropriately instantiated
                 and composed with the application's state machine to
                 prove properties about the application. We have built
                 two execution environments: one for deploying
                 applications on Android/iRobot Create platform and a
                 second one for simulating large instantiations of the
                 applications in a discrete even simulator. The
                 capabilities are illustrated with a StarL application
                 for vehicle to vehicle coordination in an automatic
                 intersection that uses primitives for point-to-point
                 motion, mutual exclusion, and registration.",
  acknowledgement = ack-nhfb,
  articleno =    "9",
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "LCTES '15 conference proceedings.",
}

@Article{Lopes:2015:HSA,
  author =       "Cristina V. Lopes and Joel Ossher",
  title =        "How scale affects structure in {Java} programs",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "10",
  pages =        "675--694",
  month =        oct,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2858965.2814300",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Feb 16 12:01:43 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Many internal software metrics and external quality
                 attributes of Java programs correlate strongly with
                 program size. This knowledge has been used pervasively
                 in quantitative studies of software through practices
                 such as normalization on size metrics. This paper
                 reports size-related super- and sublinear effects that
                 have not been known before. Findings obtained on a very
                 large collection of Java programs --- 30,911 projects
                 hosted at Google Code as of Summer 2011 --- unveils how
                 certain characteristics of programs vary
                 disproportionately with program size, sometimes even
                 non-monotonically. Many of the specific parameters of
                 nonlinear relations are reported. This result gives
                 further insights for the differences of ``programming
                 in the small'' vs. ``programming in the large.'' The
                 reported findings carry important consequences for OO
                 software metrics, and software research in general:
                 metrics that have been known to correlate with size can
                 now be properly normalized so that all the information
                 that is left in them is size-independent.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '15 conference proceedings.",
}

@Article{Madsen:2015:SAE,
  author =       "Magnus Madsen and Frank Tip and Ondrej Lhot{\'a}k",
  title =        "Static analysis of event-driven {Node.js JavaScript}
                 applications",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "10",
  pages =        "505--519",
  month =        oct,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2858965.2814272",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Feb 16 12:01:43 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Many JavaScript programs are written in an
                 event-driven style. In particular, in server-side
                 Node.js applications, operations involving sockets,
                 streams, and files are typically performed in an
                 asynchronous manner, where the execution of listeners
                 is triggered by events. Several types of programming
                 errors are specific to such event-based programs (e.g.,
                 unhandled events, and listeners that are registered too
                 late). We present the event-based call graph, a program
                 representation that can be used to detect bugs related
                 to event handling. We have designed and implemented
                 three analyses for constructing event-based call
                 graphs. Our results show that these analyses are
                 capable of detecting problems reported on
                 StackOverflow. Moreover, we show that the number of
                 false positives reported by the analysis on a suite of
                 small Node.js applications is manageable.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '15 conference proceedings.",
}

@Article{Marr:2015:TVP,
  author =       "Stefan Marr and St{\'e}phane Ducasse",
  title =        "Tracing vs. partial evaluation: comparing
                 meta-compilation approaches for self-optimizing
                 interpreters",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "10",
  pages =        "821--839",
  month =        oct,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2858965.2814275",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Feb 16 12:01:43 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Tracing and partial evaluation have been proposed as
                 meta-compilation techniques for interpreters to make
                 just-in-time compilation language-independent. They
                 promise that programs executing on simple interpreters
                 can reach performance of the same order of magnitude as
                 if they would be executed on state-of-the-art virtual
                 machines with highly optimizing just-in-time compilers
                 built for a specific language. Tracing and partial
                 evaluation approach this meta-compilation from two ends
                 of a spectrum, resulting in different sets of
                 tradeoffs. This study investigates both approaches in
                 the context of self-optimizing interpreters, a
                 technique for building fast abstract-syntax-tree
                 interpreters. Based on RPython for tracing and Truffle
                 for partial evaluation, we assess the two approaches by
                 comparing the impact of various optimizations on the
                 performance of an interpreter for SOM, an
                 object-oriented dynamically-typed language. The goal is
                 to determine whether either approach yields clear
                 performance or engineering benefits. We find that
                 tracing and partial evaluation both reach roughly the
                 same level of performance. SOM based on meta-tracing is
                 on average 3x slower than Java, while SOM based on
                 partial evaluation is on average 2.3x slower than Java.
                 With respect to the engineering, tracing has however
                 significant benefits, because it requires language
                 implementers to apply fewer optimizations to reach the
                 same level of performance.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '15 conference proceedings.",
}

@Article{Mastrangelo:2015:UYO,
  author =       "Luis Mastrangelo and Luca Ponzanelli and Andrea Mocci
                 and Michele Lanza and Matthias Hauswirth and Nathaniel
                 Nystrom",
  title =        "Use at your own risk: the {Java} unsafe {API} in the
                 wild",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "10",
  pages =        "695--710",
  month =        oct,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2858965.2814313",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Feb 16 12:01:43 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Java is a safe language. Its runtime environment
                 provides strong safety guarantees that any Java
                 application can rely on. Or so we think. We show that
                 the runtime actually does not provide these
                 guarantees---for a large fraction of today's Java code.
                 Unbeknownst to many application developers, the Java
                 runtime includes a ``backdoor'' that allows expert
                 library and framework developers to circumvent Java's
                 safety guarantees. This backdoor is there by design,
                 and is well known to experts, as it enables them to
                 write high-performance ``systems-level'' code in Java.
                 For much the same reasons that safe languages are
                 preferred over unsafe languages, these powerful---but
                 unsafe---capabilities in Java should be restricted.
                 They should be made safe by changing the language, the
                 runtime system, or the libraries. At the very least,
                 their use should be restricted. This paper is a step in
                 that direction. We analyzed 74 GB of compiled Java
                 code, spread over 86,479 Java archives, to determine
                 how Java's unsafe capabilities are used in real-world
                 libraries and applications. We found that 25\% of Java
                 bytecode archives depend on unsafe third-party Java
                 code, and thus Java's safety guarantees cannot be
                 trusted. We identify 14 different usage patterns of
                 Java's unsafe capabilities, and we provide supporting
                 evidence for why real-world code needs these
                 capabilities. Our long-term goal is to provide a
                 foundation for the design of new language features to
                 regain safety in Java.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '15 conference proceedings.",
}

@Article{Matsakis:2015:TOJ,
  author =       "Nicholas D. Matsakis and David Herman and Dmitry
                 Lomov",
  title =        "Typed objects in {JavaScript}",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "2",
  pages =        "125--134",
  month =        feb,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2775052.2661095",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue May 12 17:41:21 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "JavaScript's typed arrays have proven to be a crucial
                 API for many JS applications, particularly those
                 working with large amounts of data or emulating other
                 languages. Unfortunately, the current typed array API
                 offers no means of abstraction. Programmers are
                 supplied with a simple byte buffer that can be viewed
                 as an array of integers or floats, but nothing more.
                 This paper presents a generalization of the typed
                 arrays API entitled typed objects. The typed objects
                 API is slated for inclusion in the upcoming ES7
                 standard. The API gives users the ability to define
                 named types, making typed arrays much easier to work
                 with. In particular, it is often trivial to replace
                 uses of existing JavaScript objects with typed objects,
                 resulting in better memory consumption and more
                 predictable performance. The advantages of the typed
                 object specification go beyond convenience, however. By
                 supporting opacity---that is, the ability to deny
                 access to the raw bytes of a typed object---the new
                 typed object specification makes it possible to store
                 objects as well as scalar data and also enables more
                 optimization by JIT compilers.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "DLS '14 conference proceedings.",
}

@Article{Mirshokraie:2015:GMT,
  author =       "S. Mirshokraie and A. Mesbah and K. Pattabiraman",
  title =        "Guided Mutation Testing for {JavaScript Web}
                 Applications",
  journal =      j-IEEE-TRANS-SOFTW-ENG,
  volume =       "41",
  number =       "5",
  pages =        "429--444",
  month =        may,
  year =         "2015",
  CODEN =        "IESEDJ",
  DOI =          "https://doi.org/10.1109/TSE.2014.2371458",
  ISSN =         "0098-5589 (print), 1939-3520 (electronic)",
  ISSN-L =       "0098-5589",
  bibdate =      "Thu Feb 1 19:49:24 MST 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ieeetranssoftweng2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=6960094",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE Transactions on Software Engineering",
  journal-URL =  "http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=32",
}

@Article{Motika:2015:LWS,
  author =       "Christian Motika and Reinhard von Hanxleden",
  title =        "Light-weight {Synchronous Java (SJL)}: An approach for
                 programming deterministic reactive systems with
                 {Java}",
  journal =      j-COMPUTING,
  volume =       "97",
  number =       "3",
  pages =        "281--307",
  month =        mar,
  year =         "2015",
  CODEN =        "CMPTA2",
  DOI =          "https://doi.org/10.1007/s00607-014-0416-7",
  ISSN =         "0010-485X (print), 1436-5057 (electronic)",
  ISSN-L =       "0010-485X",
  bibdate =      "Fri Feb 9 14:53:59 MST 2018",
  bibsource =    "http://link.springer.com/journal/607/97/3;
                 https://www.math.utah.edu/pub/tex/bib/computing.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Computing",
  journal-URL =  "http://link.springer.com/journal/607",
}

@Article{Newton:2015:ALF,
  author =       "Ryan R. Newton and Peter P. Fogg and Ali Varamesh",
  title =        "Adaptive lock-free maps: purely-functional to
                 scalable",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "9",
  pages =        "218--229",
  month =        sep,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2858949.2784734",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Feb 16 12:01:43 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Purely functional data structures stored inside a
                 mutable variable provide an excellent concurrent data
                 structure-obviously correct, cheap to create, and
                 supporting snapshots. They are not, however, scalable.
                 We provide a way to retain the benefits of these
                 pure-in-a-box data structures while dynamically
                 converting to a more scalable lock-free data structure
                 under contention. Our solution scales to any pair of
                 pure and lock-free container types with key/value set
                 semantics, while retaining lock-freedom. We demonstrate
                 the principle in action on two very different
                 platforms: first in the Glasgow Haskell Compiler and
                 second in Java. To this end we extend GHC to support
                 lock-free data structures and introduce a new approach
                 for safe CAS in a lazy language.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "ICFP '15 conference proceedings.",
}

@Article{Nguyen:2015:FCR,
  author =       "Khanh Nguyen and Kai Wang and Yingyi Bu and Lu Fang
                 and Jianfei Hu and Guoqing Xu",
  title =        "{FACADE}: a Compiler and Runtime for (Almost)
                 Object-Bounded Big Data Applications",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "4",
  pages =        "675--690",
  month =        apr,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2775054.2694345",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue May 12 17:41:19 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "The past decade has witnessed the increasing demands
                 on data-driven business intelligence that led to the
                 proliferation of data-intensive applications. A managed
                 object-oriented programming language such as Java is
                 often the developer's choice for implementing such
                 applications, due to its quick development cycle and
                 rich community resource. While the use of such
                 languages makes programming easier, their automated
                 memory management comes at a cost. When the managed
                 runtime meets Big Data, this cost is significantly
                 magnified and becomes a scalability-prohibiting
                 bottleneck. This paper presents a novel compiler
                 framework, called Facade, that can generate
                 highly-efficient data manipulation code by
                 automatically transforming the data path of an existing
                 Big Data application. The key treatment is that in the
                 generated code, the number of runtime heap objects
                 created for data types in each thread is (almost)
                 statically bounded, leading to significantly reduced
                 memory management cost and improved scalability. We
                 have implemented Facade and used it to transform 7
                 common applications on 3 real-world, already
                 well-optimized Big Data frameworks: GraphChi, Hyracks,
                 and GPS. Our experimental results are very positive:
                 the generated programs have (1) achieved a 3\%--48\%
                 execution time reduction and an up to 88X GC reduction;
                 (2) consumed up to 50\% less memory, and (3) scaled to
                 much larger datasets.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "ASPLOS '15 conference proceedings.",
}

@Article{Oh:2015:MWA,
  author =       "JinSeok Oh and Jin-woo Kwon and Hyukwoo Park and
                 Soo-Mook Moon",
  title =        "Migration of {Web} Applications with Seamless
                 Execution",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "7",
  pages =        "173--185",
  month =        jul,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2817817.2731197",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Feb 16 12:01:42 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Web applications (apps) are programmed using HTML5,
                 CSS, and JavaScript, and are distributed in the source
                 code format. Web apps can be executed on any devices
                 where a web browser is installed, allowing one-source,
                 multi-platform environment. We can exploit this
                 advantage of platform independence for a new user
                 experience called app migration, which allows migrating
                 an app in the middle of execution seamlessly between
                 smart devices. This paper proposes such a migration
                 framework for web apps where we can save the current
                 state of a running app and resume its execution on a
                 different device by restoring the saved state. We save
                 the web app's state in the form of a snapshot, which is
                 actually another web app whose execution can restore
                 the saved state. In the snapshot, the state of the
                 JavaScript variables and DOM trees are saved using the
                 JSON format. We solved some of the saving/restoring
                 problems related to event handlers and closures by
                 accessing the browser and the JavaScript engine
                 internals. Our framework does not require instrumenting
                 an app or changing its source code, but works for the
                 original app. We implemented the framework on the
                 Chrome browser with the V8 JavaScript engine and
                 successfully migrated non-trivial sample apps with
                 reasonable saving and restoring overhead. We also
                 discuss other usage of the snapshot for optimizations
                 and user experiences for the web platform.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "VEE '15 conference proceedings.",
}

@Article{Olivo:2015:SDA,
  author =       "Oswaldo Olivo and Isil Dillig and Calvin Lin",
  title =        "Static detection of asymptotic performance bugs in
                 collection traversals",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "6",
  pages =        "369--378",
  month =        jun,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2813885.2737966",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Feb 16 12:01:41 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "This paper identifies and formalizes a prevalent class
                 of asymptotic performance bugs called redundant
                 traversal bugs and presents a novel static analysis for
                 automatically detecting them. We evaluate our technique
                 by implementing it in a tool called CLARITY and
                 applying it to widely-used software packages such as
                 the Google Core Collections Library, the Apache Common
                 Collections, and the Apache Ant build tool. Across 1.6M
                 lines of Java code, CLARITY finds 92 instances of
                 redundant traversal bugs, including 72 that have never
                 been previously reported, with just 5 false positives.
                 To evaluate the performance impact of these bugs, we
                 manually repair these programs and find that for an
                 input size of 50,000, all repaired programs are at
                 least 2.45 faster than their original code.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "PLDI '15 conference proceedings.",
}

@InProceedings{Oren:2015:SSP,
  author =       "Yossef Oren and Vasileios P. Kemerlis and Simha
                 Sethumadhavan and Angelos D. Keromytis",
  editor =       "Ninghui Li and Christopher Kruegel",
  booktitle =    "{CCS '15: Proceedings of the 22nd ACM SIGSAC
                 Conference on Computer and Communications Security,
                 Denver, Colorado, USA, October 12--16, 2015}",
  title =        "The Spy in the Sandbox: Practical Cache Attacks in
                 {JavaScript} and their Implications",
  publisher =    pub-ACM,
  address =      pub-ACM:adr,
  pages =        "1406--1418",
  year =         "2015",
  DOI =          "https://doi.org/10.1145/2810103.2813708",
  ISBN =         "1-4503-3832-1",
  ISBN-13 =      "978-1-4503-3832-5",
  LCCN =         "QA76.9.A25",
  bibdate =      "Tue Aug 27 06:57:02 2024",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "https://dl.acm.org/doi/10.1145/2810103.2813708",
  abstract =     "We present a micro-architectural side-channel attack
                 that runs entirely in the browser. In contrast to
                 previous work in this genre, our attack does not
                 require the attacker to install software on the
                 victim's machine; to facilitate the attack, the victim
                 needs only to browse to an untrusted webpage that
                 contains attacker-controlled content. This makes our
                 attack model highly scalable, and extremely relevant
                 and practical to today's Web, as most desktop browsers
                 currently used to access the Internet are affected by
                 such side channel threats. Our attack, which is an
                 extension to the last-level cache attacks of Liu et al.
                 [14], allows a remote adversary to recover information
                 belonging to other processes, users, and even virtual
                 machines running on the same physical host with the
                 victim web browser.\par

                 We describe the fundamentals behind our attack, and
                 evaluate its performance characteristics. In addition,
                 we show how it can be used to compromise user privacy
                 in a common setting, letting an attacker spy after a
                 victim that uses private browsing. Defending against
                 this side channel is possible, but the required
                 countermeasures can exact an impractical cost on benign
                 uses of the browser.",
  acknowledgement = ack-nhfb,
}

@Article{Park:2015:KCF,
  author =       "Daejun Park and Andrei Stefanescu and Grigore Rosu",
  title =        "{KJS}: a complete formal semantics of {JavaScript}",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "6",
  pages =        "346--356",
  month =        jun,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2813885.2737991",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Feb 16 12:01:41 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "This paper presents KJS, the most complete and
                 thoroughly tested formal semantics of JavaScript to
                 date. Being executable, KJS has been tested against the
                 ECMAScript 5.1 conformance test suite, and passes all
                 2,782 core language tests. Among the existing
                 implementations of JavaScript, only Chrome V8's passes
                 all the tests, and no other semantics passes more than
                 90\%. In addition to a reference implementation for
                 JavaScript, KJS also yields a simple coverage metric
                 for a test suite: the set of semantic rules it
                 exercises. Our semantics revealed that the ECMAScript
                 5.1 conformance test suite fails to cover several
                 semantic rules. Guided by the semantics, we wrote tests
                 to exercise those rules. The new tests revealed bugs
                 both in production JavaScript engines (Chrome V8,
                 Safari WebKit, Firefox SpiderMonkey) and in other
                 semantics. KJS is symbolically executable, thus it can
                 be used for formal analysis and verification of
                 JavaScript programs. We verified non-trivial programs
                 and found a known security vulnerability.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "PLDI '15 conference proceedings.",
}

@Article{Passerat-Palmbach:2015:TSS,
  author =       "Jonathan Passerat-Palmbach and Claude Mazel and David
                 R. C. Hill",
  title =        "{TaskLocalRandom}: a statistically sound substitute to
                 pseudorandom number generation in parallel {Java} tasks
                 frameworks",
  journal =      j-CCPE,
  volume =       "27",
  number =       "13",
  pages =        "3383--3398",
  day =          "10",
  month =        sep,
  year =         "2015",
  CODEN =        "CCPEBO",
  DOI =          "https://doi.org/10.1002/cpe.3214",
  ISSN =         "1532-0626 (print), 1532-0634 (electronic)",
  ISSN-L =       "1532-0626",
  bibdate =      "Mon Sep 28 09:32:54 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/prng.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Concurrency and Computation: Practice and Experience",
  journal-URL =  "http://www.interscience.wiley.com/jpages/1532-0626",
  onlinedate =   "18 Feb 2014",
}

@Article{Piao:2015:JJF,
  author =       "Xianglan Piao and Channoh Kim and Younghwan Oh and
                 Huiying Li and Jincheon Kim and Hanjun Kim and Jae W.
                 Lee",
  title =        "{JAWS}: a {JavaScript} framework for adaptive
                 {CPU--GPU} work sharing",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "8",
  pages =        "251--252",
  month =        aug,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2858788.2688525",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Feb 16 12:01:42 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "This paper introduces jAWS, a JavaScript framework for
                 adaptive work sharing between CPU and GPU for
                 data-parallel workloads. Unlike conventional
                 heterogeneous parallel programming environments for
                 JavaScript, which use only one compute device when
                 executing a single kernel, jAWS accelerates kernel
                 execution by exploiting both devices to realize full
                 performance potential of heterogeneous multicores. jAWS
                 employs an efficient work partitioning algorithm that
                 finds an optimal work distribution between the two
                 devices without requiring offline profiling. The jAWS
                 runtime provides shared arrays for multiple parallel
                 contexts, hence eliminating extra copy overhead for
                 input and output data. Our preliminary evaluation with
                 both CPU-friendly and GPU-friendly benchmarks
                 demonstrates that jAWS provides good load balancing and
                 efficient data communication between parallel contexts,
                 to significantly outperform best single-device
                 execution.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "PPoPP '15 conference proceedings.",
}

@Article{Pinto:2015:LSS,
  author =       "Gustavo Pinto and Weslley Torres and Benito Fernandes
                 and Fernando Castor and Roberto S. M. Barros",
  title =        "A large-scale study on the usage of {Java}'s
                 concurrent programming constructs",
  journal =      j-J-SYST-SOFTW,
  volume =       "106",
  number =       "??",
  pages =        "59--81",
  month =        aug,
  year =         "2015",
  CODEN =        "JSSODM",
  ISSN =         "0164-1212 (print), 1873-1228 (electronic)",
  ISSN-L =       "0164-1212",
  bibdate =      "Mon Jun 8 11:23:23 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/jsystsoftw.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0164121215000849",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Systems and Software",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01641212/",
}

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

@Article{Radoi:2015:WAR,
  author =       "Cosmin Radoi and Stephan Herhut and Jaswanth Sreeram
                 and Danny Dig",
  title =        "Are web applications ready for parallelism?",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "8",
  pages =        "289--290",
  month =        aug,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2858788.2700995",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Feb 16 12:01:42 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "In recent years, web applications have become
                 pervasive. Their backbone is JavaScript, the only
                 programming language supported by all major web
                 browsers. Most browsers run on desktop or mobile
                 devices with parallel hardware. However, JavaScript is
                 by design sequential, and current web applications make
                 little use of hardware parallelism. Are web
                 applications ready to exploit parallel hardware? We
                 answer the question in two steps: First, we survey 174
                 web developers about the potential and challenges of
                 using parallelism. Then, we study the performance and
                 computation shape of a set of web applications that are
                 representative for the emerging web. Our findings
                 indicate that emerging web applications do have latent
                 data parallelism, and JavaScript developers'
                 programming style is not a significant impediment to
                 exploiting this parallelism.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "PPoPP '15 conference proceedings.",
}

@Article{Ramos:2015:NCS,
  author =       "Sabela Ramos and Guillermo L. Taboada and Roberto R.
                 Exp{\'o}sito and Juan Touri{\~n}o",
  title =        "Nonblocking collectives for scalable {Java}
                 communications",
  journal =      j-CCPE,
  volume =       "27",
  number =       "5",
  pages =        "1169--1187",
  day =          "10",
  month =        apr,
  year =         "2015",
  CODEN =        "CCPEBO",
  DOI =          "https://doi.org/10.1002/cpe.3279",
  ISSN =         "1532-0626 (print), 1532-0634 (electronic)",
  ISSN-L =       "1532-0626",
  bibdate =      "Sat Jul 25 19:54:07 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Concurrency and Computation: Practice and Experience",
  journal-URL =  "http://www.interscience.wiley.com/jpages/1532-0626",
  onlinedate =   "21 Apr 2014",
}

@Article{Rastogi:2015:SEG,
  author =       "Aseem Rastogi and Nikhil Swamy and C{\'e}dric Fournet
                 and Gavin Bierman and Panagiotis Vekris",
  title =        "Safe \& Efficient Gradual Typing for {TypeScript}",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "1",
  pages =        "167--180",
  month =        jan,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2775051.2676971",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue May 12 17:41:19 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  abstract =     "Current proposals for adding gradual typing to
                 JavaScript, such as Closure, TypeScript and Dart, forgo
                 soundness to deal with issues of scale, code reuse, and
                 popular programming patterns. We show how to address
                 these issues in practice while retaining soundness. We
                 design and implement a new gradual type system,
                 prototyped for expediency as a 'Safe' compilation mode
                 for TypeScript. Our compiler achieves soundness by
                 enforcing stricter static checks and embedding residual
                 runtime checks in compiled code. It emits plain
                 JavaScript that runs on stock virtual machines. Our
                 main theorem is a simulation that ensures that the
                 checks introduced by Safe TypeScript (1) catch any
                 dynamic type error, and (2) do not alter the semantics
                 of type-safe TypeScript code. Safe TypeScript is
                 carefully designed to minimize the performance overhead
                 of runtime checks. At its core, we rely on two new
                 ideas: differential subtyping, a new form of coercive
                 subtyping that computes the minimum amount of runtime
                 type information that must be added to each object; and
                 an erasure modality, which we use to safely and
                 selectively erase type information. This allows us to
                 scale our design to full-fledged TypeScript, including
                 arrays, maps, classes, inheritance, overloading, and
                 generic types. We validate the usability and
                 performance of Safe TypeScript empirically by
                 type-checking and compiling around 120,000 lines of
                 existing TypeScript source code. Although runtime
                 checks can be expensive, the end-to-end overhead is
                 small for code bases that already have type
                 annotations. For instance, we bootstrap the Safe
                 TypeScript compiler (90,000 lines including the base
                 TypeScript compiler): we measure a 15\% runtime
                 overhead for type safety, and also uncover programming
                 errors as type safety violations. We conclude that, at
                 least during development and testing, subjecting
                 JavaScript/TypeScript programs to safe gradual typing
                 adds significant value to source type annotations at a
                 modest cost.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "POPL '15 conference proceedings.",
}

@Article{Raychev:2015:PPP,
  author =       "Veselin Raychev and Martin Vechev and Andreas Krause",
  title =        "Predicting Program Properties from {``Big Code''}",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "1",
  pages =        "111--124",
  month =        jan,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2775051.2677009",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue May 12 17:41:19 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "We present a new approach for predicting program
                 properties from massive codebases (aka ``Big Code'').
                 Our approach first learns a probabilistic model from
                 existing data and then uses this model to predict
                 properties of new, unseen programs. The key idea of our
                 work is to transform the input program into a
                 representation which allows us to phrase the problem of
                 inferring program properties as structured prediction
                 in machine learning. This formulation enables us to
                 leverage powerful probabilistic graphical models such
                 as conditional random fields (CRFs) in order to perform
                 joint prediction of program properties. As an example
                 of our approach, we built a scalable prediction engine
                 called JSNice for solving two kinds of problems in the
                 context of JavaScript: predicting (syntactic) names of
                 identifiers and predicting (semantic) type annotations
                 of variables. Experimentally, JSNice predicts correct
                 names for 63\% of name identifiers and its type
                 annotation predictions are correct in 81\% of the
                 cases. In the first week since its release, JSNice was
                 used by more than 30,000 developers and in only few
                 months has become a popular tool in the JavaScript
                 developer community. By formulating the problem of
                 inferring program properties as structured prediction
                 and showing how to perform both learning and inference
                 in this context, our work opens up new possibilities
                 for attacking a wide range of difficult problems in the
                 context of ``Big Code'' including invariant generation,
                 decompilation, synthesis and others.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "POPL '15 conference proceedings.",
}

@Article{Rhodes:2015:DDO,
  author =       "Dustin Rhodes and Tim Disney and Cormac Flanagan",
  title =        "Dynamic detection of object capability violations
                 through model checking",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "2",
  pages =        "103--112",
  month =        feb,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2775052.2661099",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue May 12 17:41:21 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "In this paper we present a new tool called DOCaT
                 (Dynamic Object Capability Tracer), a model checker for
                 JavaScript that detects capability leaks in an object
                 capability system. DOCaT includes an editor that
                 highlights the sections of code that can be potentially
                 transferred to untrusted third-party code along with a
                 trace showing how the code could be leaked in an actual
                 execution. This code highlighting provides a simple way
                 of visualizing the references untrusted code
                 potentially has access to and helps programmers to
                 discover if their code is leaking more capabilities
                 then required. DOCaT is implemented using a combination
                 of source code rewriting (using Sweet.js, a JavaScript
                 macro system), dynamic behavioral intercession
                 (Proxies, introduced in ES6, the most recent version of
                 JavaScript), and model checking. Together these methods
                 are able to locate common ways for untrusted code to
                 elevate its authority.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "DLS '14 conference proceedings.",
}

@Article{Rodeghero:2015:ETS,
  author =       "P. Rodeghero and C. Liu and P. W. McBurney and C.
                 McMillan",
  title =        "An Eye-Tracking Study of {Java} Programmers and
                 Application to Source Code Summarization",
  journal =      j-IEEE-TRANS-SOFTW-ENG,
  volume =       "41",
  number =       "11",
  pages =        "1038--1054",
  month =        nov,
  year =         "2015",
  CODEN =        "IESEDJ",
  DOI =          "https://doi.org/10.1109/TSE.2015.2442238",
  ISSN =         "0098-5589 (print), 1939-3520 (electronic)",
  ISSN-L =       "0098-5589",
  bibdate =      "Thu Feb 1 19:49:24 MST 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ieeetranssoftweng2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=7118751",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE Transactions on Software Engineering",
  journal-URL =  "http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=32",
}

@Article{Rossi:2015:NPJ,
  author =       "Gianfranco Rossi and Federico Bergenti",
  title =        "Nondeterministic Programming in {Java} with {JSetL}",
  journal =      j-FUND-INFO,
  volume =       "140",
  number =       "3--4",
  pages =        "393--412",
  month =        "????",
  year =         "2015",
  CODEN =        "FUMAAJ",
  DOI =          "https://doi.org/10.3233/FI-2015-1260",
  ISSN =         "0169-2968 (print), 1875-8681 (electronic)",
  ISSN-L =       "0169-2968",
  bibdate =      "Sat Mar 5 17:21:23 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/fundinfo2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Fundamenta Informaticae",
  journal-URL =  "http://content.iospress.com/journals/fundamenta-informaticae",
}

@Article{Samak:2015:SRT,
  author =       "Malavika Samak and Murali Krishna Ramanathan and
                 Suresh Jagannathan",
  title =        "Synthesizing racy tests",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "6",
  pages =        "175--185",
  month =        jun,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2813885.2737998",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Feb 16 12:01:41 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Subtle concurrency errors in multithreaded libraries
                 that arise because of incorrect or inadequate
                 synchronization are often difficult to pinpoint
                 precisely using only static techniques. On the other
                 hand, the effectiveness of dynamic race detectors is
                 critically dependent on multithreaded test suites whose
                 execution can be used to identify and trigger races.
                 Usually, such multithreaded tests need to invoke a
                 specific combination of methods with objects involved
                 in the invocations being shared appropriately to expose
                 a race. Without a priori knowledge of the race,
                 construction of such tests can be challenging. In this
                 paper, we present a lightweight and scalable technique
                 for synthesizing precisely these kinds of tests. Given
                 a multithreaded library and a sequential test suite, we
                 describe a fully automated analysis that examines
                 sequential execution traces, and produces as its output
                 a concurrent client program that drives shared objects
                 via library method calls to states conducive for
                 triggering a race. Experimental results on a variety of
                 well-tested Java libraries yield 101 synthesized
                 multithreaded tests in less than four minutes.
                 Analyzing the execution of these tests using an
                 off-the-shelf race detector reveals 187 harmful races,
                 including several previously unreported ones. Our
                 implementation, named NARADA, and the results of our
                 experiments are available at
                 http://www.csa.iisc.ernet.in/~sss/tools/narada.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "PLDI '15 conference proceedings.",
}

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

@Article{Simon:2015:STH,
  author =       "Doug Simon and Christian Wimmer and Bernhard Urban and
                 Gilles Duboscq and Lukas Stadler and Thomas
                 W{\"u}rthinger",
  title =        "Snippets: Taking the High Road to a Low Level",
  journal =      j-TACO,
  volume =       "12",
  number =       "2",
  pages =        "20:1--20:??",
  month =        jul,
  year =         "2015",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/2764907",
  ISSN =         "1544-3566 (print), 1544-3973 (electronic)",
  ISSN-L =       "1544-3566",
  bibdate =      "Fri Aug 7 09:46:00 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/taco.bib",
  abstract =     "When building a compiler for a high-level language,
                 certain intrinsic features of the language must be
                 expressed in terms of the resulting low-level
                 operations. Complex features are often expressed by
                 explicitly weaving together bits of low-level IR, a
                 process that is tedious, error prone, difficult to
                 read, difficult to reason about, and machine dependent.
                 In the Graal compiler for Java, we take a different
                 approach: we use snippets of Java code to express
                 semantics in a high-level, architecture-independent
                 way. Two important restrictions make snippets feasible
                 in practice: they are compiler specific, and they are
                 explicitly prepared and specialized. Snippets make
                 Graal simpler and more portable while still capable of
                 generating machine code that can compete with other
                 compilers of the Java HotSpot VM.",
  acknowledgement = ack-nhfb,
  articleno =    "20",
  fjournal =     "ACM Transactions on Architecture and Code Optimization
                 (TACO)",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J924",
}

@Article{Stancu:2015:SEH,
  author =       "Codrut Stancu and Christian Wimmer and Stefan
                 Brunthaler and Per Larsen and Michael Franz",
  title =        "Safe and efficient hybrid memory management for
                 {Java}",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "11",
  pages =        "81--92",
  month =        nov,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2887746.2754185",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Feb 16 12:01:44 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Java uses automatic memory management, usually
                 implemented as a garbage-collected heap. That lifts the
                 burden of manually allocating and deallocating memory,
                 but it can incur significant runtime overhead and
                 increase the memory footprint of applications. We
                 propose a hybrid memory management scheme that utilizes
                 region-based memory management to deallocate objects
                 automatically on region exits. Static program analysis
                 detects allocation sites that are safe for region
                 allocation, i.e., the static analysis proves that the
                 objects allocated at such a site are not reachable
                 after the region exit. A regular garbage-collected heap
                 is used for objects that are not region allocatable.
                 The region allocation exploits the temporal locality of
                 object allocation. Our analysis uses coarse-grain
                 source code annotations to disambiguate objects with
                 non-overlapping lifetimes, and maps them to different
                 memory scopes. Region-allocated memory does not require
                 garbage collection as the regions are simply
                 deallocated when they go out of scope. The region
                 allocation technique is backed by a garbage collector
                 that manages memory that is not region allocated. We
                 provide a detailed description of the analysis, provide
                 experimental results showing that as much as 78\% of
                 the memory is region allocatable and discuss how our
                 hybrid memory management system can be implemented
                 efficiently with respect to both space and time.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "ISMM '15 conference proceedings.",
}

@Article{Steindorfer:2015:CSM,
  author =       "Michael J. Steindorfer and Jurgen J. Vinju",
  title =        "Code specialization for memory efficient hash tries
                 (short paper)",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "3",
  pages =        "11--14",
  month =        mar,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2775053.2658763",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue May 12 17:41:23 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/hash.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "The hash trie data structure is a common part in
                 standard collection libraries of JVM programming
                 languages such as Clojure and Scala. It enables fast
                 immutable implementations of maps, sets, and vectors,
                 but it requires considerably more memory than an
                 equivalent array-based data structure. This hinders the
                 scalability of functional programs and the further
                 adoption of this otherwise attractive style of
                 programming. In this paper we present a product family
                 of hash tries. We generate Java source code to
                 specialize them using knowledge of JVM object memory
                 layout. The number of possible specializations is
                 exponential. The optimization challenge is thus to find
                 a minimal set of variants which lead to a maximal loss
                 in memory footprint on any given data. Using a set of
                 experiments we measured the distribution of internal
                 tree node sizes in hash tries. We used the results as a
                 guidance to decide which variants of the family to
                 generate and which variants should be left to the
                 generic implementation. A preliminary validating
                 experiment on the implementation of sets and maps shows
                 that this technique leads to a median decrease of 55\%
                 in memory footprint for maps (and 78\% for sets), while
                 still maintaining comparable performance. Our
                 combination of data analysis and code specialization
                 proved to be effective.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "GPCE '14 conference proceedings.",
}

@Article{Steindorfer:2015:OHA,
  author =       "Michael J. Steindorfer and Jurgen J. Vinju",
  title =        "Optimizing hash-array mapped tries for fast and lean
                 immutable {JVM} collections",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "10",
  pages =        "783--800",
  month =        oct,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2858965.2814312",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Feb 16 12:01:43 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/hash.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "The data structures under-pinning collection API (e.g.
                 lists, sets, maps) in the standard libraries of
                 programming languages are used intensively in many
                 applications. The standard libraries of recent Java
                 Virtual Machine languages, such as Clojure or Scala,
                 contain scalable and well-performing immutable
                 collection data structures that are implemented as
                 Hash-Array Mapped Tries (HAMTs). HAMTs already feature
                 efficient lookup, insert, and delete operations,
                 however due to their tree-based nature their memory
                 footprints and the runtime performance of iteration and
                 equality checking lag behind array-based counterparts.
                 This particularly prohibits their application in
                 programs which process larger data sets. In this paper,
                 we propose changes to the HAMT design that increase the
                 overall performance of immutable sets and maps. The
                 resulting general purpose design increases cache
                 locality and features a canonical representation. It
                 outperforms Scala's and Clojure's data structure
                 implementations in terms of memory footprint and
                 runtime efficiency of iteration (1.3-6.7x) and equality
                 checking (3-25.4x).",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '15 conference proceedings.",
}

@Article{Stilkerich:2015:PGA,
  author =       "Isabella Stilkerich and Clemens Lang and Christoph
                 Erhardt and Michael Stilkerich",
  title =        "A Practical Getaway: Applications of Escape Analysis
                 in Embedded Real-Time Systems",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "5",
  pages =        "4:1--4:??",
  month =        may,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2808704.2754961",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Jul 31 19:39:44 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "The use of a managed, type-safe language such as Java
                 in real-time and embedded systems offers productivity
                 and, in particular, safety and dependability benefits
                 at a reasonable cost. It has been shown for commodity
                 systems that escape analysis (EA) enables a set of
                 useful optimization, and benefits from the properties
                 of a type-safe language. In this paper, we explore the
                 application of escape analysis in KESO [34], a Java
                 ahead-of-time compiler targeting (deeply) embedded
                 real-time systems. We present specific applications of
                 EA for embedded programs that go beyond the widely
                 known stack-allocation and synchronization
                 optimizations such as extended remote procedure call
                 support for software-isolated applications, automated
                 inference of immutable data or improved upper space and
                 time bounds for worst-case estimations.",
  acknowledgement = ack-nhfb,
  articleno =    "4",
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "LCTES '15 conference proceedings.",
}

@Article{Stone:2015:WMT,
  author =       "James Stone and John Towse",
  title =        "A Working Memory Test Battery: {Java}-Based Collection
                 of Seven Working Memory Tasks",
  journal =      j-J-OPEN-RES-SOFT,
  volume =       "3",
  number =       "1",
  pages =        "e5--??",
  day =          "05",
  month =        jun,
  year =         "2015",
  CODEN =        "????",
  DOI =          "https://doi.org/10.5334/jors.br",
  ISSN =         "2049-9647",
  ISSN-L =       "2049-9647",
  bibdate =      "Sat Sep 8 10:03:49 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/jors.bib",
  URL =          "https://openresearchsoftware.metajnl.com/articles/10.5334/jors.br/",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Open Research Software",
  journal-URL =  "https://openresearchsoftware.metajnl.com/issue/archive/",
}

@Article{Thomson:2015:LHB,
  author =       "Paul Thomson and Alastair F. Donaldson",
  title =        "The lazy happens-before relation: better partial-order
                 reduction for systematic concurrency testing",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "8",
  pages =        "259--260",
  month =        aug,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2858788.2688533",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Feb 16 12:01:42 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "We present the lazy happens-before relation (lazy
                 HBR), which ignores mutex-induced edges to provide a
                 more precise notion of state equivalence compared with
                 the traditional happens-before relation. We demonstrate
                 experimentally that the lazy HBR has the potential to
                 provide greater schedule reduction during systematic
                 concurrency testing with respect to a set of 79 Java
                 benchmarks.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "PPoPP '15 conference proceedings.",
}

@Article{Toffola:2015:PPY,
  author =       "Luca Della Toffola and Michael Pradel and Thomas R.
                 Gross",
  title =        "Performance problems you can fix: a dynamic analysis
                 of memoization opportunities",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "10",
  pages =        "607--622",
  month =        oct,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2858965.2814290",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Feb 16 12:01:43 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Performance bugs are a prevalent problem and recent
                 research proposes various techniques to identify such
                 bugs. This paper addresses a kind of performance
                 problem that often is easy to address but difficult to
                 identify: redundant computations that may be avoided by
                 reusing already computed results for particular inputs,
                 a technique called memoization. To help developers find
                 and use memoization opportunities, we present
                 MemoizeIt, a dynamic analysis that identifies methods
                 that repeatedly perform the same computation. The key
                 idea is to compare inputs and outputs of method calls
                 in a scalable yet precise way. To avoid the overhead of
                 comparing objects at all method invocations in detail,
                 MemoizeIt first compares objects without following any
                 references and iteratively increases the depth of
                 exploration while shrinking the set of considered
                 methods. After each iteration, the approach ignores
                 methods that cannot benefit from memoization, allowing
                 it to analyze calls to the remaining methods in more
                 detail. For every memoization opportunity that
                 MemoizeIt detects, it provides hints on how to
                 implement memoization, making it easy for the developer
                 to fix the performance issue. Applying MemoizeIt to
                 eleven real-world Java programs reveals nine profitable
                 memoization opportunities, most of which are missed by
                 traditional CPU time profilers, conservative compiler
                 optimizations, and other existing approaches for
                 finding performance bugs. Adding memoization as
                 proposed by MemoizeIt leads to statistically
                 significant speedups by factors between 1.04x and
                 12.93x.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '15 conference proceedings.",
}

@Article{Tsai:2015:JPI,
  author =       "Chun-Jen Tsai and Han-Wen Kuo and Zigang Lin and
                 Zi-Jing Guo and Jun-Fu Wang",
  title =        "A {Java} Processor {IP} Design for Embedded {SoC}",
  journal =      j-TECS,
  volume =       "14",
  number =       "2",
  pages =        "35:1--35:??",
  month =        mar,
  year =         "2015",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/2629649",
  ISSN =         "1539-9087 (print), 1558-3465 (electronic)",
  ISSN-L =       "1539-9087",
  bibdate =      "Thu Mar 26 05:58:56 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/tecs.bib",
  abstract =     "In this article, we present a reusable Java processor
                 IP for application processors of embedded systems. For
                 the Java microarchitecture, we propose a low-cost stack
                 memory design that supports a two-fold instruction
                 folding pipeline and a low-complexity Java exception
                 handling hardware. We also propose a mapping between
                 the Java dynamic class loading model and the SoC
                 platform-based design principle so that the Java core
                 can be encapsulated as a reusable IP. To achieve this
                 goal, a two-level method area with two on-chip circular
                 buffers is proposed as an interface between the RISC
                 core and the Java core. The proposed architecture is
                 implemented on a Xilinx Virtex-5 FPGA device.
                 Experimental results show that its performance has some
                 advantages over other Java processors and a Java VM
                 with JIT acceleration on a PowerPC platform.",
  acknowledgement = ack-nhfb,
  articleno =    "35",
  fjournal =     "ACM Transactions on Embedded Computing Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J840",
}

@Article{Upadhyaya:2015:EML,
  author =       "Ganesha Upadhyaya and Hridesh Rajan",
  title =        "Effectively mapping linguistic abstractions for
                 message-passing concurrency to threads on the {Java
                 Virtual Machine}",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "10",
  pages =        "840--859",
  month =        oct,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2858965.2814289",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Feb 16 12:01:43 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  abstract =     "Efficient mapping of message passing concurrency (MPC)
                 abstractions to Java Virtual Machine (JVM) threads is
                 critical for performance, scalability, and CPU
                 utilization; but tedious and time consuming to perform
                 manually. In general, this mapping cannot be found in
                 polynomial time, but we show that by exploiting the
                 local characteristics of MPC abstractions and their
                 communication patterns this mapping can be determined
                 effectively. We describe our MPC abstraction to thread
                 mapping technique, its realization in two frameworks
                 (Panini and Akka), and its rigorous evaluation using
                 several benchmarks from representative MPC frameworks.
                 We also compare our technique against four default
                 mapping techniques: thread-all, round-robin-task-all,
                 random-task-all and work-stealing. Our evaluation shows
                 that our mapping technique can improve the performance
                 by 30\%-60\% over default mapping techniques. These
                 improvements are due to a number of challenges
                 addressed by our technique namely: i) balancing the
                 computations across JVM threads, ii) reducing the
                 communication overheads, iii) utilizing information
                 about cache locality, and iv) mapping MPC abstractions
                 to threads in a way that reduces the contention between
                 JVM threads.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '15 conference proceedings.",
}

@Book{Urma:2015:JAL,
  author =       "Raoul-Gabriel Urma and Mario Fusco and Alan Mycroft",
  title =        "{Java 8} in action: lambdas, streams, and
                 functional-style programming",
  publisher =    pub-MANNING,
  address =      pub-MANNING:adr,
  pages =        "xxviii + 394",
  year =         "2015",
  ISBN =         "1-61729-199-4 (paperback)",
  ISBN-13 =      "978-1-61729-199-9 (paperback)",
  LCCN =         "QA76.73.J38 U76 2015",
  bibdate =      "Thu Dec 4 13:27:00 MST 2014",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://proquest.safaribooksonline.com/?fpi=9781617291999;
                 http://proquest.tech.safaribooksonline.de/9781617291999",
  abstract =     "Every new version of Java is important, but Java 8 is
                 a game changer. Java 8 in Action is a clearly written
                 guide to the new features of Java 8. It begins with a
                 practical introduction to lambdas, using real-world
                 Java code. Next, it covers the new Streams API and
                 shows how you can use it to make collection-based code
                 radically easier to understand and maintain. It also
                 explains other major Java 8 features including default
                 methods, Optional, CompletableFuture, and the new Date
                 and Time API. This book is written for programmers
                 familiar with Java and basic OO programming.",
  acknowledgement = ack-nhfb,
  subject =      "Java (langage de programmation); Java (Computer
                 program language); Object-oriented programs (Computer
                 programs); Java (Computer program language);
                 Object-oriented programs (Computer programs)",
  tableofcontents = "Part 1 Fundamentals \\
                 Chapter 1 Java 8: why should you care? \\
                 Chapter 2 Passing code with behavior parameterization
                 \\
                 Chapter 3 Lambda expressions \\
                 Part 2 Functional-style data processing \\
                 Chapter 4 Introducing streams \\
                 Chapter 5 Working with streams \\
                 Chapter 6 Collecting data with streams \\
                 Chapter 7 Parallel data processing and performance \\
                 Part 3 Effective Java 8 programming \\
                 Chapter 8 Refactoring, testing, and debugging \\
                 Chapter 9 Default methods \\
                 Chapter 10 Using Optional as a better alternative to
                 null \\
                 Chapter 11 CompletableFuture: composable asynchronous
                 programming \\
                 Chapter 12 New Date and Time API \\
                 Part 4 Beyond Java \\
                 Chapter 13 Thinking functionally \\
                 Chapter 14 Functional programming techniques \\
                 Chapter 15 Blending OOP and FP: comparing Java 8 and
                 Scala \\
                 Chapter 16 Conclusions and where next for Java \\
                 appendix A Miscellaneous language updates \\
                 appendix B Miscellaneous library updates \\
                 appendix C Performing multiple operations in parallel
                 on a stream \\
                 Appendix D Lambdas and JVM bytecode",
}

@Article{VanCutsem:2015:RTC,
  author =       "Tom {Van Cutsem} and Mark S. Miller",
  title =        "Robust trait composition for {JavaScript}",
  journal =      j-SCI-COMPUT-PROGRAM,
  volume =       "98 (part 3)",
  number =       "??",
  pages =        "422--438",
  day =          "1",
  month =        feb,
  year =         "2015",
  CODEN =        "SCPGD4",
  ISSN =         "0167-6423 (print), 1872-7964 (electronic)",
  ISSN-L =       "0167-6423",
  bibdate =      "Thu Dec 4 19:45:00 MST 2014",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/scicomputprogram.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0167642312002079",
  acknowledgement = ack-nhfb,
  fjournal =     "Science of Computer Programming",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01676423/",
}

@Article{Yi:2015:CTC,
  author =       "Jaeheon Yi and Tim Disney and Stephen N. Freund and
                 Cormac Flanagan",
  title =        "Cooperative types for controlling thread interference
                 in {Java}",
  journal =      j-SCI-COMPUT-PROGRAM,
  volume =       "112 (part 3)",
  number =       "??",
  pages =        "227--260",
  day =          "15",
  month =        nov,
  year =         "2015",
  CODEN =        "SCPGD4",
  ISSN =         "0167-6423 (print), 1872-7964 (electronic)",
  ISSN-L =       "0167-6423",
  bibdate =      "Mon Oct 19 06:31:52 MDT 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/scicomputprogram.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0167642315001483",
  acknowledgement = ack-nhfb,
  fjournal =     "Science of Computer Programming",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01676423/",
}

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

@Article{Zabolotnyi:2015:JCG,
  author =       "Rostyslav Zabolotnyi and Philipp Leitner and Waldemar
                 Hummer and Schahram Dustdar",
  title =        "{JCloudScale}: Closing the Gap Between {IaaS} and
                 {PaaS}",
  journal =      j-TOIT,
  volume =       "15",
  number =       "3",
  pages =        "10:1--10:??",
  month =        sep,
  year =         "2015",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/2792980",
  ISSN =         "1533-5399 (print), 1557-6051 (electronic)",
  ISSN-L =       "1533-5399",
  bibdate =      "Sat Dec 19 18:06:52 MST 2015",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toit/;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/toit.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  abstract =     "Building Infrastructure-as-a-Service (IaaS)
                 applications today is a complex, repetitive, and
                 error-prone endeavor, as IaaS does not provide
                 abstractions on top of virtual machines. This article
                 presents JCloudScale, a Java-based middleware for
                 moving elastic applications to IaaS clouds, with
                 minimal adjustments to the application code. We discuss
                 the architecture and technical features, as well as
                 evaluate our system with regard to user acceptance and
                 performance overhead. Our user study reveals that
                 JCloudScale allows many participants to build IaaS
                 applications more efficiently, compared to industrial
                 Platform-as-a-Service (PaaS) solutions. Additionally,
                 unlike PaaS, JCloudScale does not lead to a control
                 loss and vendor lock-in.",
  acknowledgement = ack-nhfb,
  articleno =    "10",
  fjournal =     "ACM Transactions on Internet Technology (TOIT)",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J780",
}

@Article{Zhang:2015:LOS,
  author =       "Minjia Zhang and Jipeng Huang and Man Cao and Michael
                 D. Bond",
  title =        "Low-overhead software transactional memory with
                 progress guarantees and strong semantics",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "8",
  pages =        "97--108",
  month =        aug,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2858788.2688510",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Feb 16 12:01:42 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Software transactional memory offers an appealing
                 alternative to locks by improving programmability,
                 reliability, and scalability. However, existing STMs
                 are impractical because they add high instrumentation
                 costs and often provide weak progress guarantees and/or
                 semantics. This paper introduces a novel STM called
                 LarkTM that provides three significant features. (1)
                 Its instrumentation adds low overhead except when
                 accesses actually conflict, enabling low single-thread
                 overhead and scaling well on low-contention workloads.
                 (2) It uses eager concurrency control mechanisms, yet
                 naturally supports flexible conflict resolution,
                 enabling strong progress guarantees. (3) It naturally
                 provides strong atomicity semantics at low cost.
                 LarkTM's design works well for low-contention
                 workloads, but adds significant overhead under higher
                 contention, so we design an adaptive version of LarkTM
                 that uses alternative concurrency control for
                 high-contention objects. An implementation and
                 evaluation in a Java virtual machine show that the
                 basic and adaptive versions of LarkTM not only provide
                 low single-thread overhead, but their multithreaded
                 performance compares favorably with existing
                 high-performance STMs.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "PPoPP '15 conference proceedings.",
}

@Article{Zhang:2015:SYB,
  author =       "Haoyuan Zhang and Zewei Chu and Bruno C. d. S.
                 Oliveira and Tijs van der Storm",
  title =        "Scrap your boilerplate with object algebras",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "10",
  pages =        "127--146",
  month =        oct,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2858965.2814279",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Feb 16 12:01:43 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Traversing complex Abstract Syntax Trees (ASTs)
                 typically requires large amounts of tedious boilerplate
                 code. For many operations most of the code simply walks
                 the structure, and only a small portion of the code
                 implements the functionality that motivated the
                 traversal in the first place. This paper presents a
                 type-safe Java framework called Shy that removes much
                 of this boilerplate code. In Shy object algebras are
                 used to describe complex and extensible AST structures.
                 Using Java annotations Shy generates generic
                 boilerplate code for various types of traversals. For a
                 concrete traversal, users of Shy can then inherit from
                 the generated code and override only the interesting
                 cases. Consequently, the amount of code that users need
                 to write is significantly smaller. Moreover, traversals
                 using the Shy framework are also much more structure
                 shy, becoming more adaptive to future changes or
                 extensions to the AST structure. To prove the
                 effectiveness of the approach, we applied Shy in the
                 implementation of a domain-specific questionnaire
                 language. Our results show that for a large number of
                 traversals there was a significant reduction in the
                 amount of user-defined code.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '15 conference proceedings.",
}

@Article{Zheng:2015:APP,
  author =       "Yudi Zheng and Lubom{\'\i}r Bulej and Walter Binder",
  title =        "Accurate profiling in the presence of dynamic
                 compilation",
  journal =      j-SIGPLAN,
  volume =       "50",
  number =       "10",
  pages =        "433--450",
  month =        oct,
  year =         "2015",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2858965.2814281",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Feb 16 12:01:43 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Many profilers based on bytecode instrumentation yield
                 wrong results in the presence of an optimizing dynamic
                 compiler, either due to not being aware of
                 optimizations such as stack allocation and method
                 inlining, or due to the inserted code disrupting such
                 optimizations. To avoid such perturbations, we present
                 a novel technique to make any profiler implemented at
                 the bytecode level aware of optimizations performed by
                 the dynamic compiler. We implement our approach in a
                 state-of-the-art Java virtual machine and demonstrate
                 its significance with concrete profilers. We quantify
                 the impact of escape analysis on allocation profiling,
                 object life-time analysis, and the impact of method
                 inlining on callsite profiling. We illustrate how our
                 approach enables new kinds of profilers, such as a
                 profiler for non-inlined callsites, and a testing
                 framework for locating performance bugs in dynamic
                 compiler implementations.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '15 conference proceedings.",
}

@Article{Zhu:2015:APL,
  author =       "Xiaoyan Zhu and E. James {Whitehead, Jr.} and Caitlin
                 Sadowski and Qinbao Song",
  title =        "An analysis of programming language statement
                 frequency in {C}, {C++}, and {Java} source code",
  journal =      j-SPE,
  volume =       "45",
  number =       "11",
  pages =        "1479--1495",
  month =        nov,
  year =         "2015",
  CODEN =        "SPEXBL",
  DOI =          "https://doi.org/10.1002/spe.2298",
  ISSN =         "0038-0644 (print), 1097-024X (electronic)",
  ISSN-L =       "0038-0644",
  bibdate =      "Mon Feb 8 18:03:22 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/spe.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Software --- Practice and Experience",
  journal-URL =  "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)1097-024X",
  onlinedate =   "6 Nov 2014",
}

@Article{Abanades:2016:DAR,
  author =       "Miguel Ab{\'a}nades and Francisco Botana and
                 Zolt{\'a}n Kov{\'a}cs and Tom{\'a}s Recio and Csilla
                 S{\'o}lyom-Gecse",
  title =        "Development of automatic reasoning tools in
                 {GeoGebra}",
  journal =      j-ACM-COMM-COMP-ALGEBRA,
  volume =       "50",
  number =       "3",
  pages =        "85--88",
  month =        sep,
  year =         "2016",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/3015306.3015309",
  ISSN =         "1932-2232 (print), 1932-2240 (electronic)",
  ISSN-L =       "1932-2232",
  bibdate =      "Fri Nov 4 16:34:18 MDT 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsam.bib",
  abstract =     "Much effort has been put into the implementation of
                 automatic proving in interactive geometric environments
                 (e.g., Java Geometry Expert, GeoGebra). The closely
                 related concept of automatic discovery, remains however
                 almost unexplored. This software presentation will
                 demonstrate our results towards the incorporation of
                 automatic discovery capabilities into GeoGebra, an
                 educational software with tens of millions of users
                 worldwide. As main result, we report on a new command,
                 currently available in the official version, that
                 allows the automatic discovery of loci of points in
                 diagrams defined by implicit conditions. This
                 represents an extension of a previous command, similar
                 in nature, but restricted to loci defined by the
                 standard mover-tracer construction. Our proposal
                 successfully automates the `dummy locus dragging' in
                 dynamic geometry. This makes the cycle
                 conjecturing-checking-proving accessible for general
                 users in elementary geometry.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM Communications in Computer Algebra",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J1000",
}

@Article{Akram:2016:BPG,
  author =       "Shoaib Akram and Jennifer B. Sartor and Kenzo {Van
                 Craeynest} and Wim Heirman and Lieven Eeckhout",
  title =        "Boosting the Priority of Garbage: Scheduling
                 Collection on Heterogeneous Multicore Processors",
  journal =      j-TACO,
  volume =       "13",
  number =       "1",
  pages =        "4:1--4:??",
  month =        apr,
  year =         "2016",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/2875424",
  ISSN =         "1544-3566 (print), 1544-3973 (electronic)",
  ISSN-L =       "1544-3566",
  bibdate =      "Tue Apr 5 16:27:36 MDT 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/taco.bib",
  abstract =     "While hardware is evolving toward heterogeneous
                 multicore architectures, modern software applications
                 are increasingly written in managed languages.
                 Heterogeneity was born of a need to improve energy
                 efficiency; however, we want the performance of our
                 applications not to suffer from limited resources. How
                 best to schedule managed language applications on a mix
                 of big, out-of-order cores and small, in-order cores is
                 an open question, complicated by the host of service
                 threads that perform key tasks such as memory
                 management. These service threads compete with the
                 application for core and memory resources, and garbage
                 collection (GC) must sometimes suspend the application
                 if there is not enough memory available for allocation.
                 In this article, we explore concurrent garbage
                 collection's behavior, particularly when it becomes
                 critical, and how to schedule it on a heterogeneous
                 system to optimize application performance. While some
                 applications see no difference in performance when GC
                 threads are run on big versus small cores, others ---
                 those with GC criticality --- see up to an 18\%
                 performance improvement. We develop a new, adaptive
                 scheduling algorithm that responds to GC criticality
                 signals from the managed runtime, giving more big-core
                 cycles to the concurrent collector when it is under
                 pressure and in danger of suspending the application.
                 Our experimental results show that our
                 GC-criticality-aware scheduler is robust across a range
                 of heterogeneous architectures with different core
                 counts and frequency scaling and across heap sizes. Our
                 algorithm is performance and energy neutral for
                 GC-uncritical Java applications and significantly
                 speeds up GC-critical applications by 16\%, on average,
                 while being 20\% more energy efficient for a
                 heterogeneous multicore with three big cores and one
                 small core.",
  acknowledgement = ack-nhfb,
  articleno =    "4",
  fjournal =     "ACM Transactions on Architecture and Code Optimization
                 (TACO)",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J924",
}

@Article{Alshara:2016:MLO,
  author =       "Zakarea Alshara and Abdelhak-Djamel Seriai and Chouki
                 Tibermacine and Hinde Lilia Bouziane and Christophe
                 Dony and Anas Shatnawi",
  title =        "Migrating large object-oriented applications into
                 component-based ones: instantiation and inheritance
                 transformation",
  journal =      j-SIGPLAN,
  volume =       "51",
  number =       "3",
  pages =        "55--64",
  month =        mar,
  year =         "2016",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2936314.2814223",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Jun 9 17:13:58 MDT 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Large object-oriented applications have complex and
                 numerous dependencies, and usually do not have explicit
                 software architectures. Therefore they are hard to
                 maintain, and parts of them are difficult to reuse.
                 Component-based development paradigm emerged for
                 improving these aspects and for supporting effective
                 maintainability and reuse. It provides better
                 understandability through a high-level architecture
                 view of the application. Thereby migrating
                 object-oriented applications to component-based ones
                 will contribute to improve these characteristics
                 (maintainability and reuse). In this paper, we propose
                 an approach to automatically transform object-oriented
                 applications to component-based ones. More
                 particularly, the input of the approach is the result
                 provided by software architecture recovery: a
                 component-based architecture description. Then, our
                 approach transforms the object-oriented source code in
                 order to produce deployable components. We focus in
                 this paper on the transformation of source code related
                 to instantiation and inheritance dependencies between
                 classes that are in different components. We
                 experimented the proposed solution in the
                 transformation of a collection of Java applications
                 into the OSGi framework. The experimental results are
                 discussed in this paper.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "GPCE '15 conference proceedings.",
}

@Article{Amighi:2016:PCC,
  author =       "Afshin Amighi and Pedro de Carvalho Gomes and Dilian
                 Gurov and Marieke Huisman",
  title =        "Provably correct control flow graphs from {Java}
                 bytecode programs with exceptions",
  journal =      j-INT-J-SOFTW-TOOLS-TECHNOL-TRANSFER,
  volume =       "18",
  number =       "6",
  pages =        "653--684",
  month =        nov,
  year =         "2016",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1007/s10009-015-0375-0",
  ISSN =         "1433-2779 (print), 1433-2787 (electronic)",
  ISSN-L =       "1433-2779",
  bibdate =      "Sun Jan 1 11:13:22 MST 2017",
  bibsource =    "http://link.springer.com/journal/10009/18/6;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sttt.bib",
  URL =          "http://link.springer.com/accesspage/article/10.1007/s10009-015-0375-0;
                 http://link.springer.com/article/10.1007/s10009-015-0375-0",
  acknowledgement = ack-nhfb,
  fjournal =     "International Journal on Software Tools for Technology
                 Transfer (STTT)",
  journal-URL =  "http://link.springer.com/journal/10009",
}

@Article{Amin:2016:JST,
  author =       "Nada Amin and Ross Tate",
  title =        "{Java} and {Scala}'s type systems are unsound: the
                 existential crisis of null pointers",
  journal =      j-SIGPLAN,
  volume =       "51",
  number =       "10",
  pages =        "838--848",
  month =        oct,
  year =         "2016",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3022671.2984004",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:13 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "We present short programs that demonstrate the
                 unsoundness of Java and Scala's current type systems.
                 In particular, these programs provide parametrically
                 polymorphic functions that can turn any type into any
                 type without (down)casting. Fortunately, parametric
                 polymorphism was not integrated into the Java Virtual
                 Machine (JVM), so these examples do not demonstrate any
                 unsoundness of the JVM. Nonetheless, we discuss broader
                 implications of these findings on the field of
                 programming languages.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '16 conference proceedings.",
}

@Article{Andrysco:2016:PFP,
  author =       "Marc Andrysco and Ranjit Jhala and Sorin Lerner",
  title =        "Printing floating-point numbers: a faster, always
                 correct method",
  journal =      j-SIGPLAN,
  volume =       "51",
  number =       "1",
  pages =        "555--567",
  month =        jan,
  year =         "2016",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2914770.2837654",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Jun 9 17:13:57 MDT 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/fparith.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Floating-point numbers are an essential part of modern
                 software, recently gaining particular prominence on the
                 web as the exclusive numeric format of Javascript. To
                 use floating-point numbers, we require a way to convert
                 binary machine representations into human readable
                 decimal outputs. Existing conversion algorithms make
                 trade-offs between completeness and performance. The
                 classic Dragon4 algorithm by Steele and White and its
                 later refinements achieve completeness --- i.e. produce
                 correct and optimal outputs on all inputs --- by using
                 arbitrary precision integer (bignum) arithmetic which
                 leads to a high performance cost. On the other hand,
                 the recent Grisu3 algorithm by Loitsch shows how to
                 recover performance by using native integer arithmetic
                 but sacrifices optimality for 0.5\% of all inputs. We
                 present Errol, a new complete algorithm that is
                 guaranteed to produce correct and optimal results for
                 all inputs while simultaneously being 2x faster than
                 the incomplete Grisu3 and 4x faster than previous
                 complete methods.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "POPL '16 conference proceedings.",
}

@Article{Anjo:2016:DML,
  author =       "Ivo Anjo and Jo{\~a}o Cachopo",
  title =        "Design of a Method-Level Speculation framework for
                 boosting irregular {JVM} applications",
  journal =      j-J-PAR-DIST-COMP,
  volume =       "87",
  number =       "??",
  pages =        "13--25",
  month =        jan,
  year =         "2016",
  CODEN =        "JPDCER",
  ISSN =         "0743-7315 (print), 1096-0848 (electronic)",
  ISSN-L =       "0743-7315",
  bibdate =      "Mon Dec 21 18:24:37 MST 2015",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/jpardistcomp.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0743731515001720",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Parallel and Distributed Computing",
  journal-URL =  "http://www.sciencedirect.com/science/journal/07437315/",
}

@Article{Aumuller:2016:OPD,
  author =       "Martin Aum{\"u}ller and Martin Dietzfelbinger",
  title =        "Optimal Partitioning for Dual-Pivot {Quicksort}",
  journal =      j-TALG,
  volume =       "12",
  number =       "2",
  pages =        "18:1--18:??",
  month =        feb,
  year =         "2016",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/2743020",
  ISSN =         "1549-6325 (print), 1549-6333 (electronic)",
  ISSN-L =       "1549-6325",
  bibdate =      "Fri Feb 12 18:02:17 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/talg.bib",
  abstract =     "Dual-pivot quicksort refers to variants of classical
                 quicksort where in the partitioning step two pivots are
                 used to split the input into three segments. This can
                 be done in different ways, giving rise to different
                 algorithms. Recently, a dual-pivot algorithm due to
                 Yaroslavskiy received much attention, because it
                 replaced the well-engineered quicksort algorithm in
                 Oracle's Java 7 runtime library. Nebel and Wild (ESA
                 2012) analyzed this algorithm and showed that on
                 average it uses $ 1.9 n \ln n + O (n) $ comparisons to
                 sort an input of size $n$, beating standard quicksort,
                 which uses $ 2 n \ln n + O (n)$ comparisons. We
                 introduce a model that captures all dual-pivot
                 algorithms, give a unified analysis, and identify new
                 dual-pivot algorithms that minimize the average number
                 of key comparisons among all possible algorithms up to
                 a linear term. This minimum is $ 1.8 n \ln n + O (n)$.
                 For the case that the pivots are chosen from a small
                 sample, we include a comparison of dual-pivot quicksort
                 and classical quicksort. Specifically, we show that
                 dual-pivot quicksort benefits from a skewed choice of
                 pivots. We experimentally evaluate our algorithms and
                 compare them to Yaroslavskiy's algorithm and the
                 recently described $3$-pivot quicksort algorithm of
                 Kushagra et al. (ALENEX 2014).",
  acknowledgement = ack-nhfb,
  articleno =    "18",
  fjournal =     "ACM Transactions on Algorithms (TALG)",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J982",
}

@Article{Bonetta:2016:GSM,
  author =       "Daniele Bonetta and Luca Salucci and Stefan Marr and
                 Walter Binder",
  title =        "{GEMs}: shared-memory parallel programming for
                 {Node.js}",
  journal =      j-SIGPLAN,
  volume =       "51",
  number =       "10",
  pages =        "531--547",
  month =        oct,
  year =         "2016",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3022671.2984039",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:13 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "JavaScript is the most popular programming language
                 for client-side Web applications, and Node.js has
                 popularized the language for server-side computing,
                 too. In this domain, the minimal support for parallel
                 programming remains however a major limitation. In this
                 paper we introduce a novel parallel programming
                 abstraction called Generic Messages (GEMs). GEMs allow
                 one to combine message passing and shared-memory
                 parallelism, extending the classes of parallel
                 applications that can be built with Node.js. GEMs have
                 customizable semantics and enable several forms of
                 thread safety, isolation, and concurrency control. GEMs
                 are designed as convenient JavaScript abstractions that
                 expose high-level and safe parallelism models to the
                 developer. Experiments show that GEMs outperform
                 equivalent Node.js applications thanks to their usage
                 of shared memory.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '16 conference proceedings.",
}

@Article{Brooks:2016:CST,
  author =       "Andrew Brooks and Laura Krebs and Brandon Paulsen",
  title =        "A Comparison of Sorting Times between {Java 8} and
                 {Parallel Colt}: an Exploratory Experiment",
  journal =      j-SIGSOFT,
  volume =       "41",
  number =       "4",
  pages =        "1--5",
  month =        jul,
  year =         "2016",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/2967307.2967316",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:16:45 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  abstract =     "An exploratory experiment found that sorting arrays of
                 random integers using Java 8's parallel sort required
                 only 50\%-70\% of the time taken using the parallel
                 sort of the Parallel Colt library. Factors considered
                 responsible for the performance advantage include the
                 use of a dual-pivot quicksort on locally held data at
                 certain phases of execution and work-stealing by
                 threads, a feature of the fork--join framework. The
                 default performance of Parallel Colt's parallel sort
                 was found to degrade dramatically for small array sizes
                 due to unnecessary thread creation.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Brown:2016:HBS,
  author =       "Fraser Brown and Andres N{\"o}tzli and Dawson Engler",
  title =        "How to Build Static Checking Systems Using Orders of
                 Magnitude Less Code",
  journal =      j-OPER-SYS-REV,
  volume =       "50",
  number =       "2",
  pages =        "143--157",
  month =        jun,
  year =         "2016",
  CODEN =        "OSRED8",
  DOI =          "https://doi.org/10.1145/2954680.2872364",
  ISSN =         "0163-5980 (print), 1943-586X (electronic)",
  ISSN-L =       "0163-5980",
  bibdate =      "Thu Jun 9 17:03:34 MDT 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/opersysrev.bib",
  abstract =     "Modern static bug finding tools are complex. They
                 typically consist of hundreds of thousands of lines of
                 code, and most of them are wedded to one language (or
                 even one compiler). This complexity makes the systems
                 hard to understand, hard to debug, and hard to retarget
                 to new languages, thereby dramatically limiting their
                 scope. This paper reduces checking system complexity by
                 addressing a fundamental assumption, the assumption
                 that checkers must depend on a full-blown language
                 specification and compiler front end. Instead, our
                 program checkers are based on drastically incomplete
                 language grammars (``micro-grammars'') that describe
                 only portions of a language relevant to a checker. As a
                 result, our implementation is tiny --- roughly 2500
                 lines of code, about two orders of magnitude smaller
                 than a typical system. We hope that this dramatic
                 increase in simplicity will allow people to use more
                 checkers on more systems in more languages. We
                 implement our approach in $ \mu $ chex, a
                 language-agnostic framework for writing static bug
                 checkers. We use it to build micro-grammar based
                 checkers for six languages (C, the C preprocessor, C++,
                 Java, JavaScript, and Dart) and find over 700 errors in
                 real-world projects.",
  acknowledgement = ack-nhfb,
  fjournal =     "Operating Systems Review",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J597",
}

@Article{Chandra:2016:TIS,
  author =       "Satish Chandra and Colin S. Gordon and Jean-Baptiste
                 Jeannin and Cole Schlesinger and Manu Sridharan and
                 Frank Tip and Youngil Choi",
  title =        "Type inference for static compilation of
                 {JavaScript}",
  journal =      j-SIGPLAN,
  volume =       "51",
  number =       "10",
  pages =        "410--429",
  month =        oct,
  year =         "2016",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3022671.2984017",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:13 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "We present a type system and inference algorithm for a
                 rich subset of JavaScript equipped with objects,
                 structural subtyping, prototype inheritance, and
                 first-class methods. The type system supports abstract
                 and recursive objects, and is expressive enough to
                 accommodate several standard benchmarks with only minor
                 workarounds. The invariants enforced by the types
                 enable an ahead-of-time compiler to carry out
                 optimizations typically beyond the reach of static
                 compilers for dynamic languages. Unlike previous
                 inference techniques for prototype inheritance, our
                 algorithm uses a combination of lower and upper bound
                 propagation to infer types and discover type errors in
                 all code, including uninvoked functions. The inference
                 is expressed in a simple constraint language, designed
                 to leverage off-the-shelf fixed point solvers. We prove
                 soundness for both the type system and inference
                 algorithm. An experimental evaluation showed that the
                 inference is powerful, handling the aforementioned
                 benchmarks with no manual type annotation, and that the
                 inferred types enable effective static compilation.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '16 conference proceedings.",
}

@Article{Chapman:2016:HSH,
  author =       "Keith Chapman and Antony L. Hosking and J. Eliot B.
                 Moss",
  title =        "Hybrid {STM\slash HTM} for nested transactions on
                 {OpenJDK}",
  journal =      j-SIGPLAN,
  volume =       "51",
  number =       "10",
  pages =        "660--676",
  month =        oct,
  year =         "2016",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3022671.2984029",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:13 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Transactional memory (TM) has long been advocated as a
                 promising pathway to more automated concurrency control
                 for scaling concurrent programs running on parallel
                 hardware. Software TM (STM) has the benefit of being
                 able to run general transactional programs, but at the
                 significant cost of overheads imposed to log memory
                 accesses, mediate access conflicts, and maintain other
                 transaction metadata. Recently, hardware manufacturers
                 have begun to offer commodity hardware TM (HTM) support
                 in their processors wherein the transaction metadata is
                 maintained ``for free'' in hardware. However, HTM
                 approaches are only best-effort: they cannot
                 successfully run all transactional programs, whether
                 because of hardware capacity issues (causing large
                 transactions to fail), or compatibility restrictions on
                 the processor instructions permitted within hardware
                 transactions (causing transactions that execute those
                 instructions to fail). In such cases, programs must
                 include failure-handling code to attempt the
                 computation by some other software means, since
                 retrying the transaction would be futile. Thus, a
                 canonical use of HTM is lock elision: replacing lock
                 regions with transactions, retrying some number of
                 times in the case of conflicts, but falling back to
                 locking when HTM fails for other reasons. Here, we
                 describe how software and hardware schemes can combine
                 seamlessly into a hybrid system in support of
                 transactional programs, allowing use of low-cost HTM
                 when it works, but reverting to STM when it doesn't. We
                 describe heuristics used to make this choice
                 dynamically and automatically, but allowing the
                 transition back to HTM opportunistically. Our
                 implementation is for an extension of Java having
                 syntax for both open and closed nested transactions,
                 and boosting, running on the OpenJDK, with dynamic
                 injection of STM mechanisms (into code variants used
                 under STM) and HTM instructions (into code variants
                 used under HTM). Both schemes are compatible to allow
                 different threads to run concurrently with either
                 mechanism, while preserving transaction safety. Using a
                 standard synthetic benchmark we demonstrate that HTM
                 offers significant acceleration of both closed and open
                 nested transactions, while yielding parallel scaling up
                 to the limits of the hardware, whereupon scaling in
                 software continues but with the penalty to throughput
                 imposed by software mechanisms.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '16 conference proceedings.",
}

@Article{Chavez:2016:ACC,
  author =       "H. M. Chavez and W. Shen and R. B. France and B. A.
                 Mechling and G. Li",
  title =        "An Approach to Checking Consistency between {UML}
                 Class Model and Its {Java} Implementation",
  journal =      j-IEEE-TRANS-SOFTW-ENG,
  volume =       "42",
  number =       "4",
  pages =        "322--344",
  month =        apr,
  year =         "2016",
  CODEN =        "IESEDJ",
  DOI =          "https://doi.org/10.1109/TSE.2015.2488645",
  ISSN =         "0098-5589 (print), 1939-3520 (electronic)",
  ISSN-L =       "0098-5589",
  bibdate =      "Thu Feb 1 19:49:24 MST 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ieeetranssoftweng2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=7294689",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE Transactions on Software Engineering",
  journal-URL =  "http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=32",
}

@Article{Chen:2016:CDD,
  author =       "Yuting Chen and Ting Su and Chengnian Sun and Zhendong
                 Su and Jianjun Zhao",
  title =        "Coverage-directed differential testing of {JVM}
                 implementations",
  journal =      j-SIGPLAN,
  volume =       "51",
  number =       "6",
  pages =        "85--99",
  month =        jun,
  year =         "2016",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2980983.2908095",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Sep 5 07:32:25 MDT 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Java virtual machine (JVM) is a core technology, whose
                 reliability is critical. Testing JVM implementations
                 requires painstaking effort in designing test
                 classfiles (*.class) along with their test oracles. An
                 alternative is to employ binary fuzzing to
                 differentially test JVMs by blindly mutating seeding
                 classfiles and then executing the resulting mutants on
                 different JVM binaries for revealing inconsistent
                 behaviors. However, this blind approach is not cost
                 effective in practice because most of the mutants are
                 invalid and redundant. This paper tackles this
                 challenge by introducing classfuzz, a coverage-directed
                 fuzzing approach that focuses on representative
                 classfiles for differential testing of JVMs' startup
                 processes. Our core insight is to (1) mutate seeding
                 classfiles using a set of predefined mutation operators
                 (mutators) and employ Markov Chain Monte Carlo (MCMC)
                 sampling to guide mutator selection, and (2) execute
                 the mutants on a reference JVM implementation and use
                 coverage uniqueness as a discipline for accepting
                 representative ones. The accepted classfiles are used
                 as inputs to differentially test different JVM
                 implementations and find defects. We have implemented
                 classfuzz and conducted an extensive evaluation of it
                 against existing fuzz testing algorithms. Our
                 evaluation results show that classfuzz can enhance the
                 ratio of discrepancy-triggering classfiles from 1.7\%
                 to 11.9\%. We have also reported 62 JVM discrepancies,
                 along with the test classfiles, to JVM developers. Many
                 of our reported issues have already been confirmed as
                 JVM defects, and some even match recent clarifications
                 and changes to the Java SE 8 edition of the JVM
                 specification.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "PLDI '16 conference proceedings.",
}

@Article{Clerc:2016:OJJ,
  author =       "Xavier Clerc",
  title =        "{OCaml-Java}: The {Java Virtual Machine} as the target
                 of an {OCaml} compiler",
  journal =      j-J-FUNCT-PROGRAM,
  volume =       "26",
  number =       "",
  pages =        "e7",
  month =        "????",
  year =         "2016",
  CODEN =        "JFPRES",
  DOI =          "https://doi.org/10.1017/S0956796816000095",
  ISSN =         "0956-7968 (print), 1469-7653 (electronic)",
  ISSN-L =       "0956-7968",
  bibdate =      "Mon Jul 22 09:36:09 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/jfunctprogram.bib",
  URL =          "https://www.cambridge.org/core/journals/journal-of-functional-programming/article/ocamljava-the-java-virtual-machine-as-the-target-of-an-ocaml-compiler/EDA83983550B6025B3705E2F8D97EB81",
  acknowledgement = ack-nhfb,
  ajournal =     "J. Funct. Program.",
  fjournal =     "Journal of Functional Programming",
  journal-URL =  "https://www.cambridge.org/core/journals/journal-of-functional-programming",
  onlinedate =   "17 May 2016",
}

@Article{Cordoba-Sanchez:2016:ADS,
  author =       "Irene C{\'o}rdoba-S{\'a}nchez and Juan de Lara",
  title =        "{Ann}: a domain-specific language for the effective
                 design and validation of {Java} annotations",
  journal =      j-COMP-LANGS-SYS-STRUCT,
  volume =       "??",
  number =       "??",
  pages =        "164--190",
  month =        "????",
  year =         "2016",
  CODEN =        "????",
  ISSN =         "1477-8424 (print), 1873-6866 (electronic)",
  ISSN-L =       "1477-8424",
  bibdate =      "Wed Jun 1 06:21:45 MDT 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/complngs.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S1477842416300318",
  acknowledgement = ack-nhfb,
  fjournal =     "Computer Languages, Systems and Structures",
  journal-URL =  "http://www.sciencedirect.com/science/journal/14778424/",
}

@Article{Dietrich:2016:WJD,
  author =       "Jens Dietrich and Kamil Jezek and Premek Brada",
  title =        "What {Java} developers know about compatibility, and
                 why this matters",
  journal =      j-EMPIR-SOFTWARE-ENG,
  volume =       "21",
  number =       "3",
  pages =        "1371--1396",
  month =        jun,
  year =         "2016",
  CODEN =        "ESENFW",
  DOI =          "https://doi.org/10.1007/s10664-015-9389-1",
  ISSN =         "1382-3256 (print), 1573-7616 (electronic)",
  ISSN-L =       "1382-3256",
  bibdate =      "Fri Dec 2 09:14:43 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/empir-software-eng.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://link.springer.com/accesspage/article/10.1007/s10664-015-9389-1",
  acknowledgement = ack-nhfb,
  fjournal =     "Empirical Software Engineering",
  journal-URL =  "http://link.springer.com/journal/10664",
}

@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/java2010.bib;
                 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,
  articleno =    "7",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Doeraene:2016:PIW,
  author =       "S{\'e}bastien Doeraene and Tobias Schlatter",
  title =        "Parallel incremental whole-program optimizations for
                 {Scala.js}",
  journal =      j-SIGPLAN,
  volume =       "51",
  number =       "10",
  pages =        "59--73",
  month =        oct,
  year =         "2016",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3022671.2984013",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:13 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Whole-program optimizations are powerful tools that
                 can dramatically improve performance, size and other
                 aspects of programs. Because they depend on global
                 knowledge, they must typically be reapplied to the
                 whole program when small changes are made, which makes
                 them too slow for the development cycle. This is an
                 issue for some environments that require, or benefit a
                 lot from, whole-program optimizations, such as
                 compilation to JavaScript or to the Dalvik VM, because
                 their development cycle is slowed down either by the
                 lack of optimizations, or by the time spent on applying
                 them. We present a new approach to designing
                 incremental whole-program optimizers for
                 object-oriented and functional languages: when part of
                 a program changes, only the portions affected by the
                 changes are reoptimized. An incremental optimizer using
                 this approach for Scala.js, the Scala to JavaScript
                 compiler, demonstrates speedups from 10x to 100x
                 compared to its batch version. As a result, the
                 optimizer's running time becomes insignificant compared
                 to separate compilation, making it fit for use on every
                 compilation run during the development cycle. We also
                 show how to parallelize the incremental algorithm to
                 take advantage of multicore hardware.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '16 conference proceedings.",
}

@Article{Feeley:2016:CML,
  author =       "Marc Feeley",
  title =        "Compiling for multi-language task migration",
  journal =      j-SIGPLAN,
  volume =       "51",
  number =       "2",
  pages =        "63--77",
  month =        feb,
  year =         "2016",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2936313.2816713",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Jun 9 17:13:58 MDT 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/python.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Task migration allows a running program to continue
                 its execution in a different destination environment.
                 Increasingly, execution environments are defined by
                 combinations of cultural and technological constraints,
                 affecting the choice of host language, libraries and
                 tools. A compiler supporting multiple target
                 environments and task migration must be able to marshal
                 continuations and then unmarshal and continue their
                 execution, ideally, even if the language of the
                 destination environment is different. In this paper, we
                 propose a compilation approach based on a virtual
                 machine that strikes a balance between implementation
                 portability and efficiency. We explain its
                 implementation within a Scheme compiler targeting
                 JavaScript, PHP, Python, Ruby and Java --- some of the
                 most popular host languages for web applications. As
                 our experiments show, this approach compares well with
                 other Scheme compilers targeting high-level languages
                 in terms of execution speed, being sometimes up to 3
                 orders of magnitude faster.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "DLS '15 conference proceedings.",
}

@Article{Fischer:2016:EIE,
  author =       "Lars Fischer and Stefan Hanenberg",
  title =        "An empirical investigation of the effects of type
                 systems and code completion on {API} usability using
                 {TypeScript} and {JavaScript} in {MS Visual Studio}",
  journal =      j-SIGPLAN,
  volume =       "51",
  number =       "2",
  pages =        "154--167",
  month =        feb,
  year =         "2016",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2936313.2816720",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Jun 9 17:13:58 MDT 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Recent empirical studies that compared static and
                 dynamic type systems on API usability showed a positive
                 impact of static type systems on developer productivity
                 in most cases. Nevertheless, it is unclear how large
                 this effect is in comparison to other factors. One
                 obvious factor in programming is tooling: It is
                 commonly accepted that modern IDEs have a large
                 positive impact on developers, although it is not clear
                 which parts of modern IDEs are responsible for that.
                 One possible---and for most developers obvious
                 candidate---is code completion. This paper describes a
                 2x2 randomized trial that compares JavaScript and
                 Microsoft's statically typed alternative TypeScript
                 with and without code completion in MS Visual Studio.
                 While the experiment shows (in correspondence to
                 previous experiments) a large positive effect of the
                 statically typed language TypeScript, the code
                 completion effect is not only marginal, but also just
                 approaching statistical significance. This seems to be
                 an indicator that the effect of static type systems is
                 larger than often assumed, at least in comparison to
                 code completion.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "DLS '15 conference proceedings.",
}

@Article{Grigore:2016:ARG,
  author =       "Radu Grigore and Hongseok Yang",
  title =        "Abstraction refinement guided by a learnt
                 probabilistic model",
  journal =      j-SIGPLAN,
  volume =       "51",
  number =       "1",
  pages =        "485--498",
  month =        jan,
  year =         "2016",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2914770.2837663",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Jun 9 17:13:57 MDT 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "The core challenge in designing an effective static
                 program analysis is to find a good program abstraction
                 --- one that retains only details relevant to a given
                 query. In this paper, we present a new approach for
                 automatically finding such an abstraction. Our approach
                 uses a pessimistic strategy, which can optionally use
                 guidance from a probabilistic model. Our approach
                 applies to parametric static analyses implemented in
                 Datalog, and is based on counterexample-guided
                 abstraction refinement. For each untried abstraction,
                 our probabilistic model provides a probability of
                 success, while the size of the abstraction provides an
                 estimate of its cost in terms of analysis time.
                 Combining these two metrics, probability and cost, our
                 refinement algorithm picks an optimal abstraction. Our
                 probabilistic model is a variant of the Erdos--Renyi
                 random graph model, and it is tunable by what we call
                 hyperparameters. We present a method to learn good
                 values for these hyperparameters, by observing past
                 runs of the analysis on an existing codebase. We
                 evaluate our approach on an object sensitive pointer
                 analysis for Java programs, with two client analyses
                 (PolySite and Downcast).",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "POPL '16 conference proceedings.",
}

@Article{Grimmer:2016:HPC,
  author =       "Matthias Grimmer and Chris Seaton and Roland Schatz
                 and Thomas W{\"u}rthinger and Hanspeter
                 M{\"o}ssenb{\"o}ck",
  title =        "High-performance cross-language interoperability in a
                 multi-language runtime",
  journal =      j-SIGPLAN,
  volume =       "51",
  number =       "2",
  pages =        "78--90",
  month =        feb,
  year =         "2016",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2936313.2816714",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Jun 9 17:13:58 MDT 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Programmers combine different programming languages
                 because it 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, existing
                 cross-language mechanisms suffer from complex
                 interfaces, insufficient flexibility, or poor
                 performance. We present the TruffleVM, a multi-language
                 runtime that allows composing different language
                 implementations in a seamless way. It reduces the
                 amount of required boiler-plate code to a minimum by
                 allowing programmers to access foreign functions or
                 objects by using the notation of the host language. We
                 compose language implementations that translate source
                 code to an intermediate representation (IR), which is
                 executed on top of a shared runtime system. Language
                 implementations use language-independent messages that
                 the runtime resolves at their first execution by
                 transforming them to efficient
                 foreign-language-specific operations. The TruffleVM
                 avoids conversion or marshaling of foreign objects at
                 the language boundary and allows the dynamic compiler
                 to perform its optimizations across language
                 boundaries, which guarantees high performance. This
                 paper presents an implementation of our ideas based on
                 the Truffle system and its guest language
                 implementations JavaScript, Ruby, and C.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "DLS '15 conference proceedings.",
}

@Article{Gupta:2016:LSA,
  author =       "Kartik Gupta and V. Krishna Nandivada",
  title =        "Lexical state analyzer for {JavaCC} grammars",
  journal =      j-SPE,
  volume =       "46",
  number =       "6",
  pages =        "751--765",
  month =        jun,
  year =         "2016",
  CODEN =        "SPEXBL",
  DOI =          "https://doi.org/10.1002/spe.2322",
  ISSN =         "0038-0644 (print), 1097-024X (electronic)",
  ISSN-L =       "0038-0644",
  bibdate =      "Wed Jun 8 07:13:22 MDT 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/spe.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Software --- Practice and Experience",
  journal-URL =  "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)1097-024X",
}

@Article{Hedin:2016:IFS,
  author =       "Daniel Hedin and Luciano Bello and Andrei Sabelfeld",
  title =        "Information-flow security for {JavaScript} and its
                 {APIs}",
  journal =      j-J-COMP-SECUR,
  volume =       "24",
  number =       "2",
  pages =        "181--234",
  month =        "????",
  year =         "2016",
  CODEN =        "JCSIET",
  DOI =          "https://doi.org/10.3233/JCS-160544",
  ISSN =         "0926-227X (print), 1875-8924 (electronic)",
  ISSN-L =       "0926-227X",
  bibdate =      "Tue May 24 06:26:59 MDT 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/jcompsecur.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Computer Security",
  journal-URL =  "http://content.iospress.com/journals/journal-of-computer-security",
}

@Article{Hindle:2016:NS,
  author =       "Abram Hindle and Earl T. Barr and Mark Gabel and
                 Zhendong Su and Premkumar Devanbu",
  title =        "On the naturalness of software",
  journal =      j-CACM,
  volume =       "59",
  number =       "5",
  pages =        "122--131",
  month =        may,
  year =         "2016",
  CODEN =        "CACMA2",
  DOI =          "https://doi.org/10.1145/2902362",
  ISSN =         "0001-0782 (print), 1557-7317 (electronic)",
  ISSN-L =       "0001-0782",
  bibdate =      "Wed May 25 17:07:29 MDT 2016",
  bibsource =    "http://www.acm.org/pubs/contents/journals/cacm/;
                 https://www.math.utah.edu/pub/tex/bib/cacm2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://cacm.acm.org/magazines/2016/5/201595/fulltext",
  abstract =     "Natural languages like English are rich, complex, and
                 powerful. The highly creative and graceful use of
                 languages like English and Tamil, by masters like
                 Shakespeare and Avvaiyar, can certainly delight and
                 inspire. But in practice, given cognitive constraints
                 and the exigencies of daily life, most human utterances
                 are far simpler and much more repetitive and
                 predictable. In fact, these utterances can be very
                 usefully modeled using modern statistical methods. This
                 fact has led to the phenomenal success of statistical
                 approaches to speech recognition, natural language
                 translation, question-answering, and text mining and
                 comprehension. We begin with the conjecture that most
                 software is also natural, in the sense that it is
                 created by humans at work, with all the attendant
                 constraints and limitations---and thus, like natural
                 language, it is also likely to be repetitive and
                 predictable. We then proceed to ask whether (a) code
                 can be usefully modeled by statistical language models
                 and (b) such models can be leveraged to support
                 software engineers. Using the widely adopted n -gram
                 model, we provide empirical evidence supportive of a
                 positive answer to both these questions. We show that
                 code is also very regular, and, in fact, even more so
                 than natural languages. As an example use of the model,
                 we have developed a simple code completion engine for
                 Java that, despite its simplicity, already improves
                 Eclipse's completion capability. We conclude the paper
                 by laying out a vision for future research in this
                 area.",
  acknowledgement = ack-nhfb,
  fjournal =     "Communications of the ACM",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J79",
}

@InProceedings{Holzinger:2016:DSM,
  author =       "P. Holzinger and S. Triller and A. Bartel and E.
                 Bodden",
  editor =       "{ACM}",
  booktitle =    "Proceedings of the {ACM SIGSAC} Conference on
                 Computer and Communications Security",
  title =        "An in-depth study of more than ten years of {Java}
                 exploitation",
  publisher =    pub-ACM,
  address =      pub-ACM:adr,
  pages =        "779--790",
  year =         "2016",
  DOI =          "https://doi.org/10.1145/2976749.2978361",
  bibdate =      "Mon Jun 5 13:46:37 2023",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
}

@Article{Hunt:2016:RFF,
  author =       "Pete Hunt and Paul O'Shannessy and Dave Smith and
                 Terry Coatta",
  title =        "React: {Facebook}'s Functional Turn on Writing
                 {JavaScript}",
  journal =      j-QUEUE,
  volume =       "14",
  number =       "4",
  pages =        "40",
  month =        jul,
  year =         "2016",
  CODEN =        "AQCUAE",
  DOI =          "https://doi.org/10.1145/2984629.2994373",
  ISSN =         "1542-7730 (print), 1542-7749 (electronic)",
  ISSN-L =       "1542-7730",
  bibdate =      "Wed Dec 11 08:08:28 MST 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/queue.bib",
  URL =          "http://queue.acm.org/detail.cfm?id=2994373",
  abstract =     "A discussion with Pete Hunt, Paul O'Shannessy, Dave
                 Smith and Terry Coatta.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM Queue: Tomorrow's Computing Today",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J882",
}

@Article{Inostroza:2016:MIM,
  author =       "Pablo Inostroza and Tijs van der Storm",
  title =        "Modular interpreters for the masses: implicit context
                 propagation using object algebras",
  journal =      j-SIGPLAN,
  volume =       "51",
  number =       "3",
  pages =        "171--180",
  month =        mar,
  year =         "2016",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2936314.2814209",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Jun 9 17:13:58 MDT 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Modular interpreters have the potential to achieve
                 component-based language development: instead of
                 writing language interpreters from scratch, they can be
                 assembled from reusable, semantic building blocks.
                 Unfortunately, traditional language interpreters are
                 hard to extend because different language constructs
                 may require different interpreter signatures. For
                 instance, arithmetic interpreters produce a value
                 without any context information, whereas binding
                 constructs require an additional environment. In this
                 paper, we present a practical solution to this problem
                 based on implicit context propagation. By structuring
                 denotational-style interpreters as Object Algebras,
                 base interpreters can be retroactively lifted into new
                 interpreters that have an extended signature. The
                 additional parameters are implicitly propagated behind
                 the scenes, through the evaluation of the base
                 interpreter. Interpreter lifting enables a flexible
                 style of component-based language development. The
                 technique works in mainstream object-oriented
                 languages, does not sacrifice type safety or separate
                 compilation, and can be easily automated. We illustrate
                 implicit context propagation using a modular definition
                 of Featherweight Java and its extension to support
                 side-effects.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "GPCE '15 conference proceedings.",
}

@Article{Iranmanesh:2016:SSE,
  author =       "Zeinab Iranmanesh and Mehran S. Fallah",
  title =        "Specification and static enforcement of
                 scheduler-independent noninterference in a middleweight
                 {Java}",
  journal =      j-COMP-LANGS-SYS-STRUCT,
  volume =       "46",
  number =       "??",
  pages =        "20--43",
  month =        nov,
  year =         "2016",
  CODEN =        "????",
  ISSN =         "1477-8424 (print), 1873-6866 (electronic)",
  ISSN-L =       "1477-8424",
  bibdate =      "Thu Nov 17 09:48:26 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/complngs.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S1477842415300300",
  acknowledgement = ack-nhfb,
  fjournal =     "Computer Languages, Systems and Structures",
  journal-URL =  "http://www.sciencedirect.com/science/journal/14778424/",
}

@Article{Javed:2016:TSJ,
  author =       "Ansar Javed and Bibrak Qamar and Mohsan Jameel and
                 Aamir Shafi and Bryan Carpenter",
  title =        "Towards Scalable {Java} {HPC} with Hybrid and Native
                 Communication Devices in {MPJ} Express",
  journal =      j-INT-J-PARALLEL-PROG,
  volume =       "44",
  number =       "6",
  pages =        "1142--1172",
  month =        dec,
  year =         "2016",
  CODEN =        "IJPPE5",
  DOI =          "https://doi.org/10.1007/s10766-015-0375-4",
  ISSN =         "0885-7458 (print), 1573-7640 (electronic)",
  ISSN-L =       "0885-7458",
  bibdate =      "Tue Sep 20 10:50:01 MDT 2016",
  bibsource =    "http://link.springer.com/journal/10766/44/6;
                 https://www.math.utah.edu/pub/tex/bib/intjparallelprogram.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://link.springer.com/article/10.1007/s10766-015-0375-4",
  acknowledgement = ack-nhfb,
  fjournal =     "International Journal of Parallel Programming",
  journal-URL =  "http://link.springer.com/journal/10766",
}

@Article{Kedlaya:2016:SST,
  author =       "Madhukar N. Kedlaya and Behnam Robatmili and Ben
                 Hardekopf",
  title =        "Server-side type profiling for optimizing client-side
                 {JavaScript} engines",
  journal =      j-SIGPLAN,
  volume =       "51",
  number =       "2",
  pages =        "140--153",
  month =        feb,
  year =         "2016",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2936313.2816719",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Jun 9 17:13:58 MDT 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Modern JavaScript engines optimize hot functions using
                 a JIT compiler along with type information gathered by
                 an online profiler. However, the profiler's information
                 can be unsound and when unexpected types are
                 encountered the engine must recover using an expensive
                 mechanism called deoptimization. In this paper we
                 describe a method to significantly reduce the number of
                 deoptimizations observed by client-side JavaScript
                 engines by using ahead-of-time profiling on the
                 server-side. Unlike previous work on ahead-of-time
                 profiling for statically-typed languages such as Java,
                 our technique must operate on a dynamically-typed
                 language, which significantly changes the required
                 insights and methods to make the technique effective.
                 We implement our proposed technique using the
                 SpiderMonkey JavaScript engine, and we evaluate our
                 implementation using three different kinds of
                 benchmarks: the industry-standard Octane benchmark
                 suite, a set of JavaScript physics engines, and a set
                 of real-world websites from the Membench50 benchmark
                 suite. We show that using ahead-of-time profiling
                 provides significant performance benefits over the
                 baseline vanilla SpiderMonkey engine.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "DLS '15 conference proceedings.",
}

@Article{Kulkarni:2016:APA,
  author =       "Sulekha Kulkarni and Ravi Mangal and Xin Zhang and
                 Mayur Naik",
  title =        "Accelerating program analyses by cross-program
                 training",
  journal =      j-SIGPLAN,
  volume =       "51",
  number =       "10",
  pages =        "359--377",
  month =        oct,
  year =         "2016",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3022671.2984023",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:13 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Practical programs share large modules of code.
                 However, many program analyses are ineffective at
                 reusing analysis results for shared code across
                 programs. We present POLYMER, an analysis optimizer to
                 address this problem. POLYMER runs the analysis offline
                 on a corpus of training programs and learns analysis
                 facts over shared code. It prunes the learnt facts to
                 eliminate intermediate computations and then reuses
                 these pruned facts to accelerate the analysis of other
                 programs that share code with the training corpus. We
                 have implemented POLYMER to accelerate analyses
                 specified in Datalog, and apply it to optimize two
                 analyses for Java programs: a call-graph analysis that
                 is flow- and context-insensitive, and a points-to
                 analysis that is flow- and context-sensitive. We
                 evaluate the resulting analyses on ten programs from
                 the DaCapo suite that share the JDK library. POLYMER
                 achieves average speedups of 2.6$ \times $ for the
                 call-graph analysis and 5.2$ \times $ for the points-to
                 analysis.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '16 conference proceedings.",
}

@Article{Landman:2016:EAR,
  author =       "Davy Landman and Alexander Serebrenik and Eric Bouwers
                 and Jurgen J. Vinju",
  title =        "Empirical analysis of the relationship between {CC}
                 and {SLOC} in a large corpus of {Java} methods and {C}
                 functions",
  journal =      j-J-SOFTW-EVOL-PROC,
  volume =       "28",
  number =       "7",
  pages =        "589--618",
  month =        jul,
  year =         "2016",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1002/smr.1760",
  ISSN =         "2047-7473 (print), 2047-7481 (electronic)",
  ISSN-L =       "2047-7473",
  bibdate =      "Wed Jan 31 13:48:43 MST 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/jsoftwevolproc.bib",
  note =         "See corrigendum \cite{Landman:2017:CEA}.",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Software: Evolution and Process",
  journal-URL =  "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)2047-7481",
}

@Article{Lee:2016:ECP,
  author =       "Seong-Won Lee and Soo-Mook Moon and Seong-Moo Kim",
  title =        "Extended Conference Papers: Flow-sensitive runtime
                 estimation: an enhanced hot spot detection heuristics
                 for embedded {Java} just-in-time compilers",
  journal =      j-SPE,
  volume =       "46",
  number =       "6",
  pages =        "841--864",
  month =        jun,
  year =         "2016",
  CODEN =        "SPEXBL",
  DOI =          "https://doi.org/10.1002/spe.2315",
  ISSN =         "0038-0644 (print), 1097-024X (electronic)",
  ISSN-L =       "0038-0644",
  bibdate =      "Wed Jun 8 07:13:22 MDT 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/spe.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Software --- Practice and Experience",
  journal-URL =  "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)1097-024X",
}

@Article{Leopoldseder:2016:JJT,
  author =       "David Leopoldseder and Lukas Stadler and Christian
                 Wimmer and Hanspeter M{\"o}ssenb{\"o}ck",
  title =        "{Java-to-JavaScript} translation via structured
                 control flow reconstruction of compiler {IR}",
  journal =      j-SIGPLAN,
  volume =       "51",
  number =       "2",
  pages =        "91--103",
  month =        feb,
  year =         "2016",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2936313.2816715",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Jun 9 17:13:58 MDT 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "We present an approach to cross-compile Java bytecodes
                 to Java-Script, building on existing Java optimizing
                 compiler technology. Static analysis determines which
                 Java classes and methods are reachable. These are then
                 translated to JavaScript using a re-configured Java
                 just-in-time compiler with a new back end that
                 generates JavaScript instead of machine code. Standard
                 compiler optimizations such as method inlining and
                 global value numbering, as well as advanced
                 optimizations such as escape analysis, lead to compact
                 and optimized JavaScript code. Compiler IR is
                 unstructured, so structured control flow needs to be
                 reconstructed before code generation is possible. We
                 present details of our control flow reconstruction
                 algorithm. Our system is based on Graal, an open-source
                 optimizing compiler for the Java HotSpot VM and other
                 VMs. The modular and VM-independent architecture of
                 Graal allows us to reuse the intermediate
                 representation, the bytecode parser, and the high-level
                 optimizations. Our custom back end first performs
                 control flow reconstruction and then JavaScript code
                 generation. The generated JavaScript undergoes a set of
                 optimizations to increase readability and performance.
                 Static analysis is performed on the Graal intermediate
                 representation as well. Benchmark results for
                 medium-sized Java benchmarks such as SPECjbb2005 run
                 with acceptable performance on the V8 JavaScript VM.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "DLS '15 conference proceedings.",
}

@Article{Li:2016:JJM,
  author =       "Bing Li and Junbo Zhang and Ning Yu and Yi Pan",
  title =        "{J2M}: a {Java} to {MapReduce} translator for cloud
                 computing",
  journal =      j-J-SUPERCOMPUTING,
  volume =       "72",
  number =       "5",
  pages =        "1928--1945",
  month =        may,
  year =         "2016",
  CODEN =        "JOSUED",
  DOI =          "https://doi.org/10.1007/s11227-016-1695-x",
  ISSN =         "0920-8542 (print), 1573-0484 (electronic)",
  ISSN-L =       "0920-8542",
  bibdate =      "Mon May 30 09:17:38 MDT 2016",
  bibsource =    "http://link.springer.com/journal/11227/72/5;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/jsuper.bib",
  URL =          "http://link.springer.com/article/10.1007/s11227-016-1695-x",
  acknowledgement = ack-nhfb,
  fjournal =     "The Journal of Supercomputing",
  journal-URL =  "http://link.springer.com/journal/11227",
}

@Article{Lorenzen:2016:STD,
  author =       "Florian Lorenzen and Sebastian Erdweg",
  title =        "Sound type-dependent syntactic language extension",
  journal =      j-SIGPLAN,
  volume =       "51",
  number =       "1",
  pages =        "204--216",
  month =        jan,
  year =         "2016",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2914770.2837644",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Jun 9 17:13:57 MDT 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Syntactic language extensions can introduce new
                 facilities into a programming language while requiring
                 little implementation effort and modest changes to the
                 compiler. It is typical to desugar language extensions
                 in a distinguished compiler phase after parsing or type
                 checking, not affecting any of the later compiler
                 phases. If desugaring happens before type checking, the
                 desugaring cannot depend on typing information and type
                 errors are reported in terms of the generated code. If
                 desugaring happens after type checking, the code
                 generated by the desugaring is not type checked and may
                 introduce vulnerabilities. Both options are
                 undesirable. We propose a system for syntactic
                 extensibility where desugaring happens after type
                 checking and desugarings are guaranteed to only
                 generate well-typed code. A major novelty of our work
                 is that desugarings operate on typing derivations
                 instead of plain syntax trees. This provides
                 desugarings access to typing information and forms the
                 basis for the soundness guarantee we provide, namely
                 that a desugaring generates a valid typing derivation.
                 We have implemented our system for syntactic
                 extensibility in a language-independent fashion and
                 instantiated it for a substantial subset of Java,
                 including generics and inheritance. We provide a sound
                 Java extension for Scala-like for-comprehensions.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "POPL '16 conference proceedings.",
}

@Article{Maas:2016:THL,
  author =       "Martin Maas and Krste Asanovi{\'c} and Tim Harris and
                 John Kubiatowicz",
  title =        "{Taurus}: a Holistic Language Runtime System for
                 Coordinating Distributed Managed-Language
                 Applications",
  journal =      j-OPER-SYS-REV,
  volume =       "50",
  number =       "2",
  pages =        "457--471",
  month =        jun,
  year =         "2016",
  CODEN =        "OSRED8",
  DOI =          "https://doi.org/10.1145/2954680.2872386",
  ISSN =         "0163-5980 (print), 1943-586X (electronic)",
  ISSN-L =       "0163-5980",
  bibdate =      "Thu Jun 9 17:03:34 MDT 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/opersysrev.bib",
  abstract =     "Many distributed workloads in today's data centers are
                 written in managed languages such as Java or Ruby.
                 Examples include big data frameworks such as Hadoop,
                 data stores such as Cassandra or applications such as
                 the SOLR search engine. These workloads typically run
                 across many independent language runtime systems on
                 different nodes. This setup represents a source of
                 inefficiency, as these language runtime systems are
                 unaware of each other. For example, they may perform
                 Garbage Collection at times that are locally reasonable
                 but not in a distributed setting. We address these
                 problems by introducing the concept of a Holistic
                 Runtime System that makes runtime-level decisions for
                 the entire distributed application rather than locally.
                 We then present Taurus, a Holistic Runtime System
                 prototype. Taurus is a JVM drop-in replacement,
                 requires almost no configuration and can run unmodified
                 off-the-shelf Java applications. Taurus enforces
                 user-defined coordination policies and provides a DSL
                 for writing these policies. By applying Taurus to
                 Garbage Collection, we demonstrate the potential of
                 such a system and use it to explore coordination
                 strategies for the runtime systems of real-world
                 distributed applications, to improve application
                 performance and address tail-latencies in
                 latency-sensitive workloads.",
  acknowledgement = ack-nhfb,
  fjournal =     "Operating Systems Review",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J597",
}

@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/java2010.bib;
                 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,
  articleno =    "16",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Marz:2016:RPC,
  author =       "Stephen Marz and Brad {Vander Zanden}",
  title =        "Reducing Power Consumption and Latency in Mobile
                 Devices Using an Event Stream Model",
  journal =      j-TECS,
  volume =       "16",
  number =       "1",
  pages =        "11:1--11:??",
  month =        nov,
  year =         "2016",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/2964203",
  ISSN =         "1539-9087 (print), 1558-3465 (electronic)",
  ISSN-L =       "1539-9087",
  bibdate =      "Thu Nov 3 16:48:38 MDT 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/tecs.bib",
  abstract =     "Most consumer-based mobile devices use asynchronous
                 events to awaken apps. Currently, event handling is
                 implemented in either an application or an application
                 framework such as Java's virtual machine (VM) or
                 Microsoft's .NET, and it uses a ``polling loop'' that
                 periodically queries an event queue to determine if an
                 event has occurred. These loops must awaken the
                 process, check for an event, and then put the process
                 back to sleep many times per second. This constant
                 arousal prevents the CPU from being put into a deep
                 sleep state, which increases power consumption.
                 Additionally, the process cannot check for events while
                 it sleeps, and this delay in handling events increases
                 latency, which is the time that elapses between when an
                 event occurs and when the application responds to the
                 event. We call this model of event handling a ``pull''
                 model because it needs to query hardware devices or
                 software queues in order to ``pull'' events from them.
                 Recent advances in input devices support direct,
                 informative interrupts to the kernel when an event
                 occurs. This allows us to develop a much more efficient
                 event-handling model called the ``Event Stream Model''
                 (ESM). This model is a push model that allows a process
                 to sleep as long as no event occurs but then
                 immediately awakens a process when an event occurs.
                 This model eliminates the polling loop, thus
                 eliminating latency-inducing sleep between polls and
                 reducing unnecessary power consumption. To work
                 properly, the ESM model must be implemented in the
                 kernel rather than in the application. In this article,
                 we describe how we implemented the ESM model in Android
                 operating system (OS). Our results show that with the
                 event stream model, power consumption is reduced by up
                 to 23.8\% in certain circumstances, and latency is
                 reduced by an average of 13.6ms.",
  acknowledgement = ack-nhfb,
  articleno =    "11",
  fjournal =     "ACM Transactions on Embedded Computing Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J840",
  remark =       "Special issue on VIPES, special issue on ICESS2015 and
                 regular papers.",
}

@Article{McBurney:2016:ASC,
  author =       "P. W. McBurney and C. McMillan",
  title =        "Automatic Source Code Summarization of Context for
                 {Java} Methods",
  journal =      j-IEEE-TRANS-SOFTW-ENG,
  volume =       "42",
  number =       "2",
  pages =        "103--119",
  month =        feb,
  year =         "2016",
  CODEN =        "IESEDJ",
  DOI =          "https://doi.org/10.1109/TSE.2015.2465386",
  ISSN =         "0098-5589 (print), 1939-3520 (electronic)",
  ISSN-L =       "0098-5589",
  bibdate =      "Thu Feb 1 19:49:24 MST 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ieeetranssoftweng2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=7181703",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE Transactions on Software Engineering",
  journal-URL =  "http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=32",
}

@Article{McKinley:2016:PWU,
  author =       "Kathryn S. McKinley",
  title =        "Programming the world of uncertain things (keynote)",
  journal =      j-SIGPLAN,
  volume =       "51",
  number =       "1",
  pages =        "1--2",
  month =        jan,
  year =         "2016",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2914770.2843895",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Jun 9 17:13:57 MDT 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Computing has entered the era of uncertain data, in
                 which hardware and software generate and reason about
                 estimates. Applications use estimates from sensors,
                 machine learning, big data, humans, and approximate
                 hardware and software. Unfortunately, developers face
                 pervasive correctness, programmability, and
                 optimization problems due to estimates. Most
                 programming languages unfortunately make these problems
                 worse. We propose a new programming abstraction called
                 {Uncertain$<$T$>$} embedded into languages, such as
                 C\#, C++, Java, Python, and JavaScript. Applications
                 that consume estimates use familiar discrete operations
                 for their estimates; overloaded conditional operators
                 specify hypothesis tests and applications use them
                 control false positives and negatives; and new
                 compositional operators express domain knowledge. By
                 carefully restricting the expressiveness, the runtime
                 automatically implements correct statistical reasoning
                 at conditionals, relieving developers of the need to
                 implement or deeply understand statistics. We
                 demonstrate substantial programmability, correctness,
                 and efficiency benefits of this programming model for
                 GPS sensor navigation, approximate computing, machine
                 learning, and xBox.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "POPL '16 conference proceedings.",
}

@Article{Mehrnezhad:2016:TIU,
  author =       "Maryam Mehrnezhad and Ehsan Toreini and Siamak F.
                 Shahandashti and Feng Hao",
  title =        "{{\em TouchSignatures}}: Identification of user touch
                 actions and {PINs} based on mobile sensor data via
                 {JavaScript}",
  journal =      j-J-INFO-SEC-APPL,
  volume =       "26",
  number =       "??",
  pages =        "23--38",
  month =        feb,
  year =         "2016",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1016/j.jisa.2015.11.007",
  ISSN =         "2214-2126",
  ISSN-L =       "2214-2126",
  bibdate =      "Sun May 8 11:59:10 MDT 2022",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/jinfosecappl.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S2214212615000678",
  acknowledgement = ack-nhfb,
  ajournal =     "J. Info. Sec. Appl.",
  fjournal =     "Journal of Information Security and Applications
                 (JISA)",
  journal-URL =  "http://www.sciencedirect.com/science/journal/22142126",
}

@Article{Mitropoulos:2016:HTY,
  author =       "Dimitris Mitropoulos and Konstantinos Stroggylos and
                 Diomidis Spinellis and Angelos D. Keromytis",
  title =        "How to Train Your Browser: Preventing {XSS} Attacks
                 Using Contextual Script Fingerprints",
  journal =      j-TOPS,
  volume =       "19",
  number =       "1",
  pages =        "2:1--2:??",
  month =        aug,
  year =         "2016",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/2939374",
  ISSN =         "2471-2566 (print), 2471-2574 (electronic)",
  ISSN-L =       "2471-2566",
  bibdate =      "Mon Apr 3 09:09:38 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/tops.bib",
  abstract =     "Cross-Site Scripting (XSS) is one of the most common
                 web application vulnerabilities. It is therefore
                 sometimes referred to as the ``buffer overflow of the
                 web.'' Drawing a parallel from the current state of
                 practice in preventing unauthorized native code
                 execution (the typical goal in a code injection), we
                 propose a script whitelisting approach to tame
                 JavaScript-driven XSS attacks. Our scheme involves a
                 transparent script interception layer placed in the
                 browser's JavaScript engine. This layer is designed to
                 detect every script that reaches the browser, from
                 every possible route, and compare it to a list of valid
                 scripts for the site or page being accessed; scripts
                 not on the list are prevented from executing. To avoid
                 the false positives caused by minor syntactic changes
                 (e.g., due to dynamic code generation), our layer uses
                 the concept of contextual fingerprints when comparing
                 scripts. Contextual fingerprints are identifiers that
                 represent specific elements of a script and its
                 execution context. Fingerprints can be easily enriched
                 with new elements, if needed, to enhance the proposed
                 method's robustness. The list can be populated by the
                 website's administrators or a trusted third party. To
                 verify our approach, we have developed a prototype and
                 tested it successfully against an extensive array of
                 attacks that were performed on more than 50 real-world
                 vulnerable web applications. We measured the browsing
                 performance overhead of the proposed solution on eight
                 websites that make heavy use of JavaScript. Our
                 mechanism imposed an average overhead of 11.1\% on the
                 execution time of the JavaScript engine. When measured
                 as part of a full browsing session, and for all tested
                 websites, the overhead introduced by our layer was less
                 than 0.05\%. When script elements are altered or new
                 scripts are added on the server side, a new fingerprint
                 generation phase is required. To examine the temporal
                 aspect of contextual fingerprints, we performed a
                 short-term and a long-term experiment based on the same
                 websites. The former, showed that in a short period of
                 time (10 days), for seven of eight websites, the
                 majority of valid fingerprints stay the same (more than
                 92\% on average). The latter, though, indicated that,
                 in the long run, the number of fingerprints that do not
                 change is reduced. Both experiments can be seen as one
                 of the first attempts to study the feasibility of a
                 whitelisting approach for the web.",
  acknowledgement = ack-nhfb,
  articleno =    "2",
  fjournal =     "ACM Transactions on Privacy and Security (TOPS)",
  journal-URL =  "http://dl.acm.org/citation.cfm?id=J1547",
}

@Article{Na:2016:JPC,
  author =       "Yeoul Na and Seon Wook Kim and Youngsun Han",
  title =        "{JavaScript} Parallelizing Compiler for Exploiting
                 Parallelism from Data-Parallel {HTML5} Applications",
  journal =      j-TACO,
  volume =       "12",
  number =       "4",
  pages =        "64:1--64:??",
  month =        jan,
  year =         "2016",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/2846098",
  ISSN =         "1544-3566 (print), 1544-3973 (electronic)",
  ISSN-L =       "1544-3566",
  bibdate =      "Tue Feb 16 15:36:38 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/taco.bib",
  abstract =     "With the advent of the HTML5 standard, JavaScript is
                 increasingly processing computationally intensive,
                 data-parallel workloads. Thus, the enhancement of
                 JavaScript performance has been emphasized because the
                 performance gap between JavaScript and native
                 applications is still substantial. Despite this
                 urgency, conventional JavaScript compilers do not
                 exploit much of parallelism even from data-parallel
                 JavaScript applications, despite contemporary mobile
                 devices being equipped with expensive parallel hardware
                 platforms, such as multicore processors and GPGPUs. In
                 this article, we propose an automatically parallelizing
                 JavaScript compiler that targets emerging,
                 data-parallel HTML5 applications by leveraging the
                 mature affine loop analysis of conventional static
                 compilers. We identify that the most critical issues
                 when parallelizing JavaScript with a conventional
                 static analysis are ensuring correct parallelization,
                 minimizing compilation overhead, and conducting
                 low-cost recovery when there is a speculation failure
                 during parallel execution. We propose a mechanism for
                 safely handling the failure at a low cost, based on
                 compiler techniques and the property of idempotence.
                 Our experiment shows that the proposed JavaScript
                 parallelizing compiler detects most affine parallel
                 loops. Also, we achieved a maximum speedup of 3.22
                 times on a quad-core system, while incurring negligible
                 compilation and recovery overheads with various sets of
                 data-parallel HTML5 applications.",
  acknowledgement = ack-nhfb,
  articleno =    "64",
  fjournal =     "ACM Transactions on Architecture and Code Optimization
                 (TACO)",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J924",
}

@Article{Nunez:2016:PGC,
  author =       "Diogenes Nunez and Samuel Z. Guyer and Emery D.
                 Berger",
  title =        "Prioritized garbage collection: explicit {GC} support
                 for software caches",
  journal =      j-SIGPLAN,
  volume =       "51",
  number =       "10",
  pages =        "695--710",
  month =        oct,
  year =         "2016",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3022671.2984028",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:13 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Programmers routinely trade space for time to increase
                 performance, often in the form of caching or
                 memoization. In managed languages like Java or
                 JavaScript, however, this space-time tradeoff is
                 complex. Using more space translates into higher
                 garbage collection costs, especially at the limit of
                 available memory. Existing runtime systems provide
                 limited support for space-sensitive algorithms, forcing
                 programmers into difficult and often brittle choices
                 about provisioning. This paper presents prioritized
                 garbage collection, a cooperative programming language
                 and runtime solution to this problem. Prioritized GC
                 provides an interface similar to soft references,
                 called priority references, which identify objects that
                 the collector can reclaim eagerly if necessary. The key
                 difference is an API for defining the policy that
                 governs when priority references are cleared and in
                 what order. Application code specifies a priority value
                 for each reference and a target memory bound. The
                 collector reclaims references, lowest priority first,
                 until the total memory footprint of the cache fits
                 within the bound. We use this API to implement a
                 space-aware least-recently-used (LRU) cache, called a
                 Sache, that is a drop-in replacement for existing
                 caches, such as Google's Guava library. The garbage
                 collector automatically grows and shrinks the Sache in
                 response to available memory and workload with minimal
                 provisioning information from the programmer. Using a
                 Sache, it is almost impossible for an application to
                 experience a memory leak, memory pressure, or an
                 out-of-memory crash caused by software caching.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '16 conference proceedings.",
}

@Article{Olsson:2016:ERR,
  author =       "Ronald A. Olsson and Todd Williamson",
  title =        "Experience Reports: {RJ}: a {Java} package providing
                 {JR-like} concurrent programming",
  journal =      j-SPE,
  volume =       "46",
  number =       "5",
  pages =        "685--708",
  month =        may,
  year =         "2016",
  CODEN =        "SPEXBL",
  DOI =          "https://doi.org/10.1002/spe.2330",
  ISSN =         "0038-0644 (print), 1097-024X (electronic)",
  ISSN-L =       "0038-0644",
  bibdate =      "Wed Jun 8 07:13:22 MDT 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/spe.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Software --- Practice and Experience",
  journal-URL =  "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)1097-024X",
}

@Article{Pawlak:2016:SLI,
  author =       "Renaud Pawlak and Martin Monperrus and Nicolas
                 Petitprez and Carlos Noguera and Lionel Seinturier",
  title =        "{SPOON}: a library for implementing analyses and
                 transformations of {Java} source code",
  journal =      j-SPE,
  volume =       "46",
  number =       "9",
  pages =        "1155--1179",
  month =        sep,
  year =         "2016",
  CODEN =        "SPEXBL",
  DOI =          "https://doi.org/10.1002/spe.2346",
  ISSN =         "0038-0644 (print), 1097-024X (electronic)",
  ISSN-L =       "0038-0644",
  bibdate =      "Tue Sep 13 08:44:22 MDT 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/spe.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Software --- Practice and Experience",
  journal-URL =  "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)1097-024X",
}

@Article{Petrashko:2016:CGL,
  author =       "Dmitry Petrashko and Vlad Ureche and Ondrej Lhot{\'a}k
                 and Martin Odersky",
  title =        "Call graphs for languages with parametric
                 polymorphism",
  journal =      j-SIGPLAN,
  volume =       "51",
  number =       "10",
  pages =        "394--409",
  month =        oct,
  year =         "2016",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3022671.2983991",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:13 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "The performance of contemporary object oriented
                 languages depends on optimizations such as
                 devirtualization, inlining, and specialization, and
                 these in turn depend on precise call graph analysis.
                 Existing call graph analyses do not take advantage of
                 the information provided by the rich type systems of
                 contemporary languages, in particular generic type
                 arguments. Many existing approaches analyze Java
                 bytecode, in which generic types have been erased. This
                 paper shows that this discarded information is actually
                 very useful as the context in a context-sensitive
                 analysis, where it significantly improves precision and
                 keeps the running time small. Specifically, we propose
                 and evaluate call graph construction algorithms in
                 which the contexts of a method are (i) the type
                 arguments passed to its type parameters, and (ii) the
                 static types of the arguments passed to its term
                 parameters. The use of static types from the caller as
                 context is effective because it allows more precise
                 dispatch of call sites inside the callee. Our
                 evaluation indicates that the average number of
                 contexts required per method is small. We implement the
                 analysis in the Dotty compiler for Scala, and evaluate
                 it on programs that use the type-parametric Scala
                 collections library and on the Dotty compiler itself.
                 The context-sensitive analysis runs 1.4x faster than a
                 context-insensitive one and discovers 20\% more
                 monomorphic call sites at the same time. When applied
                 to method specialization, the imprecision in a
                 context-insensitive call graph would require the
                 average method to be cloned 22 times, whereas the
                 context-sensitive call graph indicates a much more
                 practical 1.00 to 1.50 clones per method. We applied
                 the proposed analysis to automatically specialize
                 generic methods. The resulting automatic transformation
                 achieves the same performance as state-of-the-art
                 techniques requiring manual annotations, while reducing
                 the size of the generated bytecode by up to 5 $ \times
                 $.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '16 conference proceedings.",
}

@Article{Pichon-Pharabod:2016:CSR,
  author =       "Jean Pichon-Pharabod and Peter Sewell",
  title =        "A concurrency semantics for relaxed atomics that
                 permits optimisation and avoids thin-air executions",
  journal =      j-SIGPLAN,
  volume =       "51",
  number =       "1",
  pages =        "622--633",
  month =        jan,
  year =         "2016",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2914770.2837616",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Jun 9 17:13:57 MDT 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Despite much research on concurrent programming
                 languages, especially for Java and C/C++, we still do
                 not have a satisfactory definition of their semantics,
                 one that admits all common optimisations without also
                 admitting undesired behaviour. Especially problematic
                 are the ``thin-air'' examples involving
                 high-performance concurrent accesses, such as C/C++11
                 relaxed atomics. The C/C++11 model is in a
                 per-candidate-execution style, and previous work has
                 identified a tension between that and the fact that
                 compiler optimisations do not operate over single
                 candidate executions in isolation; rather, they operate
                 over syntactic representations that represent all
                 executions. In this paper we propose a novel approach
                 that circumvents this difficulty. We define a
                 concurrency semantics for a core calculus, including
                 relaxed-atomic and non-atomic accesses, and locks, that
                 admits a wide range of optimisation while still
                 forbidding the classic thin-air examples. It also
                 addresses other problems relating to undefined
                 behaviour. The basic idea is to use an event-structure
                 representation of the current state of each thread,
                 capturing all of its potential executions, and to
                 permit interleaving of execution and transformation
                 steps over that to reflect optimisation (possibly
                 dynamic) of the code. These are combined with a
                 non-multi-copy-atomic storage subsystem, to reflect
                 common hardware behaviour. The semantics is defined in
                 a mechanised and executable form, and designed to be
                 implementable above current relaxed hardware and strong
                 enough to support the programming idioms that C/C++11
                 does for this fragment. It offers a potential way
                 forward for concurrent programming language semantics,
                 beyond the current C/C++11 and Java models.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "POPL '16 conference proceedings.",
}

@Article{Portillo-Dominguez:2016:ECP,
  author =       "A. Omar Portillo-Dominguez and Philip Perry and Damien
                 Magoni and Miao Wang and John Murphy",
  title =        "Extended Conference Paper: {TRINI}: an adaptive load
                 balancing strategy based on garbage collection for
                 clustered {Java} systems",
  journal =      j-SPE,
  volume =       "46",
  number =       "12",
  pages =        "1705--1733",
  month =        dec,
  year =         "2016",
  CODEN =        "SPEXBL",
  DOI =          "https://doi.org/10.1002/spe.2391",
  ISSN =         "0038-0644 (print), 1097-024X (electronic)",
  ISSN-L =       "0038-0644",
  bibdate =      "Tue Nov 15 15:25:10 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/spe.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Software --- Practice and Experience",
  journal-URL =  "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)1097-024X",
}

@Article{Qian:2016:EFS,
  author =       "Junjie Qian and Witawas Srisa-an and Sharad Seth and
                 Hong Jiang and Du Li and Pan Yi",
  title =        "Exploiting {FIFO} Scheduler to Improve Parallel
                 Garbage Collection Performance",
  journal =      j-SIGPLAN,
  volume =       "51",
  number =       "7",
  pages =        "109--121",
  month =        jul,
  year =         "2016",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3007611.2892248",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:12 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Recent studies have found that parallel garbage
                 collection performs worse with more CPUs and more
                 collector threads. As part of this work, we further
                 investigate this phenomenon and find that poor
                 scalability is worst in highly scalable Java
                 applications. Our investigation to find the causes
                 clearly reveals that efficient multi-threading in an
                 application can prolong the average object lifespan,
                 which results in less effective garbage collection. We
                 also find that prolonging lifespan is the direct result
                 of Linux's Completely Fair Scheduler due to its
                 round-robin like behavior that can increase the heap
                 contention between the application threads. Instead, if
                 we use pseudo first-in-first-out to schedule
                 application threads in large multicore systems, the
                 garbage collection scalability is significantly
                 improved while the time spent in garbage collection is
                 reduced by as much as 21\%. The average execution time
                 of the 24 Java applications used in our study is also
                 reduced by 11\%. Based on this observation, we propose
                 two approaches to optimally select scheduling policies
                 based on application scalability profile. Our first
                 approach uses the profile information from one
                 execution to tune the subsequent executions. Our second
                 approach dynamically collects profile information and
                 performs policy selection during execution.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "VEE '16 conference proceedings.",
}

@Article{Raychev:2016:PMC,
  author =       "Veselin Raychev and Pavol Bielik and Martin Vechev",
  title =        "Probabilistic model for code with decision trees",
  journal =      j-SIGPLAN,
  volume =       "51",
  number =       "10",
  pages =        "731--747",
  month =        oct,
  year =         "2016",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3022671.2984041",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:13 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "In this paper we introduce a new approach for learning
                 precise and general probabilistic models of code based
                 on decision tree learning. Our approach directly
                 benefits an emerging class of statistical programming
                 tools which leverage probabilistic models of code
                 learned over large codebases (e.g., GitHub) to make
                 predictions about new programs (e.g., code completion,
                 repair, etc). The key idea is to phrase the problem of
                 learning a probabilistic model of code as learning a
                 decision tree in a domain specific language over
                 abstract syntax trees (called TGen). This allows us to
                 condition the prediction of a program element on a
                 dynamically computed context. Further, our problem
                 formulation enables us to easily instantiate known
                 decision tree learning algorithms such as ID3, but also
                 to obtain new variants we refer to as ID3+ and E13, not
                 previously explored and ones that outperform ID3 in
                 prediction accuracy. Our approach is general and can be
                 used to learn a probabilistic model of any programming
                 language. We implemented our approach in a system
                 called Deep3 and evaluated it for the challenging task
                 of learning probabilistic models of JavaScript and
                 Python. Our experimental results indicate that Deep3
                 predicts elements of JavaScript and Python code with
                 precision above 82\% and 69\%, respectively. Further,
                 Deep3 often significantly outperforms state-of-the-art
                 approaches in overall prediction accuracy.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '16 conference proceedings.",
}

@Article{Rehman:2016:VMJ,
  author =       "Waqas Ur Rehman and Muhammad Sohaib Ayub and Junaid
                 Haroon Siddiqui",
  title =        "Verification of {MPI} {Java} programs using software
                 model checking",
  journal =      j-SIGPLAN,
  volume =       "51",
  number =       "8",
  pages =        "55:1--55:??",
  month =        aug,
  year =         "2016",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3016078.2851192",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:12 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/pvm.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Development of concurrent software requires the
                 programmer to be aware of non-determinism, data races,
                 and deadlocks. MPI (message passing interface) is a
                 popular standard for writing message oriented
                 distributed applications. Some messages in MPI systems
                 can be processed by one of the many machines and in
                 many possible orders. This non-determinism can affect
                 the result of an MPI application. The alternate results
                 may or may not be correct. To verify MPI applications,
                 we need to check all these possible orderings and use
                 an application specific oracle to decide if these
                 orderings give correct output. MPJ Express is an open
                 source Java implementation of the MPI standard. We
                 developed a Java based model of MPJ Express, where
                 processes are modeled as threads, and which can run
                 unmodified MPI Java programs on a single system. This
                 enabled us to adapt the Java PathFinder explicit state
                 software model checker (JPF) using a custom listener to
                 verify our model running real MPI Java programs. We
                 evaluated our approach using small examples where model
                 checking revealed message orders that would result in
                 incorrect system behavior.",
  acknowledgement = ack-nhfb,
  articleno =    "55",
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "PPoPP '16 conference proceedings.",
}

@Article{Reynders:2016:GSB,
  author =       "Bob Reynders and Dominique Devriese and Frank
                 Piessens",
  title =        "Generating safe boundary {APIs} between typed {EDSLs}
                 and their environments",
  journal =      j-SIGPLAN,
  volume =       "51",
  number =       "3",
  pages =        "31--34",
  month =        mar,
  year =         "2016",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2936314.2814219",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Jun 9 17:13:58 MDT 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Embedded domain specific languages (EDSLs) are used to
                 represent special-purpose code in a general-purpose
                 language and they are used for applications like vector
                 calculations and run-time code generation. Often, code
                 in an EDSL is compiled to a target (e.g. GPU languages,
                 JVM bytecode, assembly, JavaScript) and needs to
                 interface with other code that is available at that
                 level but uses other data representations or calling
                 conventions. We present an approach for safely making
                 available such APIs in a typed EDSL, guaranteeing
                 correct conversions between data representations and
                 the respect for calling conventions. When the code
                 being interfaced with is the result of static
                 compilation of host language code, we propose a way to
                 auto-generate the needed boilerplate using
                 meta-programming. We instantiate our technique with
                 JavaScript as the target language, JS-Scala as the
                 EDSL, Scala.js as the static compiler and Scala macros
                 to generate the boilerplate, but our design is more
                 generally applicable. We provide evidence of usefulness
                 of our approach through a prototype implementation that
                 we have applied in a non-trivial code base.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "GPCE '15 conference proceedings.",
}

@Article{Ryu:2016:JFB,
  author =       "Sukyoung Ryu",
  title =        "Journey to find bugs in {JavaScript} web applications
                 in the wild",
  journal =      j-SIGPLAN,
  volume =       "51",
  number =       "9",
  pages =        "2--2",
  month =        sep,
  year =         "2016",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3022670.2976747",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:13 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Analyzing real-world JavaScript web applications is a
                 challenging task. On top of understanding the semantics
                 of JavaScript, it requires modeling of web documents,
                 platform objects, and interactions between them. Not
                 only the JavaScript language itself but also its usage
                 patterns are extremely dynamic. JavaScript can generate
                 code and run it during evaluation, and most web
                 applications load JavaScript code dynamically. Such
                 dynamic characteristics of JavaScript web applications
                 make pure static analysis approaches inapplicable. In
                 this talk, we present our attempts to analyze
                 JavaScript web applications in the wild mostly
                 statically using various approaches. From pure
                 JavaScript programs to JavaScript web applications
                 using platform-specific libraries and dynamic code
                 loading, we explain technical challenges in analyzing
                 each of them and how we built an open-source analysis
                 framework for JavaScript, SAFE, that addresses the
                 challenges incrementally. In spite of active research
                 accomplishments in analysis of JavaScript web
                 applications, many issues still remain to be resolved
                 such as events, callback functions, and hybrid web
                 applications. We discuss possible future research
                 directions and open challenges.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "ICFP '16 conference proceedings.",
}

@Article{Samak:2016:DSF,
  author =       "Malavika Samak and Omer Tripp and Murali Krishna
                 Ramanathan",
  title =        "Directed synthesis of failing concurrent executions",
  journal =      j-SIGPLAN,
  volume =       "51",
  number =       "10",
  pages =        "430--446",
  month =        oct,
  year =         "2016",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3022671.2984040",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:13 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Detecting concurrency-induced bugs in multithreaded
                 libraries can be challenging due to the intricacies
                 associated with their manifestation. This includes
                 invocation of multiple methods, synthesis of inputs to
                 the methods to reach the failing location, and crafting
                 of thread interleavings that cause the erroneous
                 behavior. Neither fuzzing-based testing techniques nor
                 over-approximate static analyses are well positioned to
                 detect such subtle defects while retaining high
                 accuracy alongside satisfactory coverage. In this
                 paper, we propose a directed, iterative and scalable
                 testing engine that combines the strengths of static
                 and dynamic analysis to help synthesize concurrent
                 executions to expose complex concurrency-induced bugs.
                 Our engine accepts as input the library, its client
                 (either sequential or concurrent) and a specification
                 of correctness. Then, it iteratively refines the client
                 to generate an execution that can break the input
                 specification. Each step of the iterative process
                 includes statically identifying sub-goals towards the
                 goal of failing the specification, generating a plan
                 toward meeting these goals, and merging of the paths
                 traversed dynamically with the plan computed statically
                 via constraint solving to generate a new client. The
                 engine reports full reproduction scenarios, guaranteed
                 to be true, for the bugs it finds. We have created a
                 prototype of our approach named MINION. We validated
                 MINION by applying it to well-tested concurrent classes
                 from popular Java libraries, including the latest
                 versions of OpenJDK and Google-Guava. We were able to
                 detect 31 real crashes across 10 classes in a total of
                 23 minutes, including previously unknown bugs.
                 Comparison with three other tools reveals that
                 combined, they report only 9 of the 31 crashes (and no
                 other crashes beyond MINION). This is because several
                 of these bugs manifest under deeply nested path
                 conditions (observed maximum of 11), deep nesting of
                 method invocations (observed maximum of 6) and multiple
                 refinement iterations to generate the crash-inducing
                 client.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '16 conference proceedings.",
}

@Article{Scherr:2016:AFC,
  author =       "Maximilian Scherr and Shigeru Chiba",
  title =        "Almost first-class language embedding: taming staged
                 embedded {DSLs}",
  journal =      j-SIGPLAN,
  volume =       "51",
  number =       "3",
  pages =        "21--30",
  month =        mar,
  year =         "2016",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2936314.2814217",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Thu Jun 9 17:13:58 MDT 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Embedded domain-specific languages (EDSLs), inheriting
                 a general-purpose language's features as well as
                 look-and-feel, have traditionally been second-class or
                 rather non-citizens in terms of host-language design.
                 This makes sense when one regards them to be on the
                 same level as traditional, non-EDSL library interfaces.
                 However, this equivalence only applies to the simplest
                 of EDSLs. In this paper we illustrate why this is
                 detrimental when moving on to EDSLs that employ
                 staging, i.e. program reification, by example of
                 various issues that affect authors and users alike. We
                 believe that if EDSLs are to be considered a reliable,
                 language-like interface abstraction, they require
                 exceptional attention and design scrutiny. Instead of
                 unenforceable conventions, we advocate the acceptance
                 of EDSLs as proper, i.e. almost first-class, citizens
                 while retaining most advantages of pure embeddings. As
                 a small step towards this goal, we present a pragmatic
                 framework prototype for Java. It is based on
                 annotations that explicate and document membership to
                 explicit EDSL entities. In a nutshell, our framework
                 identifies (annotated) method calls and field accesses
                 as EDSL terms and dynamically constructs an
                 abstract-syntax representation, which is eventually
                 passed to a semantics-defining back end implemented by
                 the EDSL author.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "GPCE '15 conference proceedings.",
}

@Article{Serbanescu:2016:DPO,
  author =       "V. Serbanescu and K. Azadbakht and F. de Boer and C.
                 Nagarajagowda and B. Nobakht",
  title =        "A design pattern for optimizations in data intensive
                 applications using {ABS} and {JAVA 8}",
  journal =      j-CCPE,
  volume =       "28",
  number =       "2",
  pages =        "374--385",
  month =        feb,
  year =         "2016",
  CODEN =        "CCPEBO",
  DOI =          "https://doi.org/10.1002/cpe.3480",
  ISSN =         "1532-0626 (print), 1532-0634 (electronic)",
  ISSN-L =       "1532-0626",
  bibdate =      "Tue Feb 9 06:13:21 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Concurrency and Computation: Practice and Experience",
  journal-URL =  "http://www.interscience.wiley.com/jpages/1532-0626",
  onlinedate =   "31 Mar 2015",
}

@Article{Serrano:2016:GH,
  author =       "Manuel Serrano and Vincent Prunet",
  title =        "A glimpse of {Hopjs}",
  journal =      j-SIGPLAN,
  volume =       "51",
  number =       "9",
  pages =        "180--192",
  month =        sep,
  year =         "2016",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3022670.2951916",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:13 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Hop.js is a multitier programming environment for
                 JavaScript. It allows a single JavaScript program to
                 describe the client-side and the server-side components
                 of a web application. Its runtime environment ensures
                 consistent executions of the application on the server
                 and on the client. This paper overviews the Hop.js
                 design. It shows the JavaScript extensions that makes
                 it possible to conceive web applications globally. It
                 presents how Hop.js interacts with the outside world.
                 It also briefly presents the Hop.js implementation. It
                 presents the Hop.js web server implementation, the
                 handling of server-side parallelism, and the JavaScript
                 and HTML compilers.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "ICFP '16 conference proceedings.",
}

@Article{Sluanschi:2016:AAD,
  author =       "Emil I. Slu{\c{s}}anschi and Vlad Dumitrel",
  title =        "{ADiJaC} --- Automatic Differentiation of {Java}
                 Classfiles",
  journal =      j-TOMS,
  volume =       "43",
  number =       "2",
  pages =        "9:1--9:33",
  month =        sep,
  year =         "2016",
  CODEN =        "ACMSCU",
  DOI =          "https://doi.org/10.1145/2904901",
  ISSN =         "0098-3500 (print), 1557-7295 (electronic)",
  ISSN-L =       "0098-3500",
  bibdate =      "Tue Nov 22 17:45:25 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/toms.bib",
  URL =          "http://dl.acm.org/citation.cfm?id=2904901",
  acknowledgement = ack-nhfb,
  articleno =    "9",
  journal-URL =  "http://dl.acm.org/pub.cfm?id=J782",
}

@Article{Sousa:2016:CHL,
  author =       "Marcelo Sousa and Isil Dillig",
  title =        "{Cartesian} {Hoare} logic for verifying $k$-safety
                 properties",
  journal =      j-SIGPLAN,
  volume =       "51",
  number =       "6",
  pages =        "57--69",
  month =        jun,
  year =         "2016",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/2980983.2908092",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Sep 5 07:32:25 MDT 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Unlike safety properties which require the absence of
                 a ``bad'' program trace, k-safety properties stipulate
                 the absence of a ``bad'' interaction between $k$
                 traces. Examples of $k$-safety properties include
                 transitivity, associativity, anti-symmetry, and
                 monotonicity. This paper presents a sound and
                 relatively complete calculus, called Cartesian Hoare
                 Logic (CHL), for verifying $k$-safety properties. We
                 also present an automated verification algorithm based
                 on CHL and implement it in a tool called DESCARTES. We
                 use DESCARTES to analyze user-defined relational
                 operators in Java and demonstrate that DESCARTES is
                 effective at verifying (or finding violations of)
                 multiple $k$-safety properties.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "PLDI '16 conference proceedings.",
}

@InProceedings{Spoto:2016:JSA,
  author =       "Fausto Spoto",
  booktitle =    "{Static Analysis}",
  title =        "The {Julia} Static Analyzer for {Java}",
  publisher =    pub-SV,
  address =      pub-SV:adr,
  pages =        "39--57",
  year =         "2016",
  DOI =          "https://doi.org/10.1007/978-3-662-53413-7_3",
  bibdate =      "Fri Apr 9 07:54:52 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/julia.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-662-53413-7_3",
  acknowledgement = ack-nhfb,
}

@Article{Stefanescu:2016:SBP,
  author =       "Andrei Stefanescu and Daejun Park and Shijiao Yuwen
                 and Yilong Li and Grigore Rosu",
  title =        "Semantics-based program verifiers for all languages",
  journal =      j-SIGPLAN,
  volume =       "51",
  number =       "10",
  pages =        "74--91",
  month =        oct,
  year =         "2016",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3022671.2984027",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:13 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "We present a language-independent verification
                 framework that can be instantiated with an operational
                 semantics to automatically generate a program verifier.
                 The framework treats both the operational semantics and
                 the program correctness specifications as reachability
                 rules between matching logic patterns, and uses the
                 sound and relatively complete reachability logic proof
                 system to prove the specifications using the semantics.
                 We instantiate the framework with the semantics of one
                 academic language, KernelC, as well as with three
                 recent semantics of real-world languages, C, Java, and
                 JavaScript, developed independently of our verification
                 infrastructure. We evaluate our approach empirically
                 and show that the generated program verifiers can check
                 automatically the full functional correctness of
                 challenging heap-manipulating programs implementing
                 operations on list and tree data structures, like AVL
                 trees. This is the first approach that can turn the
                 operational semantics of real-world languages into
                 correct-by-construction automatic verifiers.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '16 conference proceedings.",
}

@Article{Steimann:2016:CRA,
  author =       "Friedrich Steimann and J{\"o}rg Hagemann and Bastian
                 Ulke",
  title =        "Computing repair alternatives for malformed programs
                 using constraint attribute grammars",
  journal =      j-SIGPLAN,
  volume =       "51",
  number =       "10",
  pages =        "711--730",
  month =        oct,
  year =         "2016",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3022671.2984007",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:13 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Attribute grammars decorate the nodes of a program's
                 parse tree with attributes whose values are defined by
                 equations encoding the (static) semantics of a
                 programming language. We show how replacing the
                 equations of an attribute grammar with equivalent
                 constraints that can be solved by a constraint solver
                 allows us to compute repairs of a malformed program
                 solely from a specification that was originally
                 designed for checking its well-formedness. We present
                 two repair modes --- shallow and deep fixing --- whose
                 computed repair alternatives are guaranteed to repair
                 every error on which they are invoked. While shallow
                 fixing may introduce new errors, deep fixing never
                 does; to make it tractable, we implement it using
                 neighborhood search. We demonstrate the feasibility of
                 our approach by implementing it on top of ExtendJ, an
                 attribute grammar based Java compiler, and by applying
                 it to an example from the Java EE context, detecting
                 and fixing well-formedness errors (both real and
                 injected) in a body of 14 open-source subject
                 programs.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '16 conference proceedings.",
}

@Article{Surendran:2016:APP,
  author =       "Rishi Surendran and Vivek Sarkar",
  title =        "Automatic parallelization of pure method calls via
                 conditional future synthesis",
  journal =      j-SIGPLAN,
  volume =       "51",
  number =       "10",
  pages =        "20--38",
  month =        oct,
  year =         "2016",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3022671.2984035",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:13 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "We introduce a novel approach for using futures to
                 automatically parallelize the execution of pure method
                 calls. Our approach is built on three new techniques to
                 address the challenge of automatic parallelization via
                 future synthesis: candidate future synthesis,
                 parallelism benefit analysis, and threshold expression
                 synthesis. During candidate future synthesis, our
                 system annotates pure method calls as async expressions
                 and synthesizes a parallel program with future objects
                 and their type declarations. Next, the system performs
                 a parallel benefit analysis to determine which async
                 expressions may need to be executed sequentially due to
                 overhead reasons, based on execution profile
                 information collected from multiple test inputs.
                 Finally, threshold expression synthesis uses the output
                 from parallelism benefit analysis to synthesize
                 predicate expressions that can be used to determine at
                 runtime if a specific pure method call should be
                 executed sequentially or in parallel. We have
                 implemented our approach, and the results obtained from
                 an experimental evaluation of the complete system on a
                 range of sequential Java benchmarks are very
                 encouraging. Our evaluation shows that our approach can
                 provide significant parallel speedups of up to 7.4 $
                 \times $ (geometric mean of 3.69 $ \times $) relative
                 to the sequential programs when using 8 processor
                 cores, with zero programmer effort beyond providing the
                 sequential program and test cases for parallelism
                 benefit analysis.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '16 conference proceedings.",
}

@Article{Vega-Gisbert:2016:DIJ,
  author =       "Oscar Vega-Gisbert and Jose E. Roman and Jeffrey M.
                 Squyres",
  title =        "Design and implementation of {Java} bindings in {Open
                 MPI}",
  journal =      j-PARALLEL-COMPUTING,
  volume =       "59",
  number =       "??",
  pages =        "1--20",
  month =        nov,
  year =         "2016",
  CODEN =        "PACOEJ",
  ISSN =         "0167-8191 (print), 1872-7336 (electronic)",
  ISSN-L =       "0167-8191",
  bibdate =      "Sat Nov 26 12:06:01 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/parallelcomputing.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0167819116300758",
  acknowledgement = ack-nhfb,
  fjournal =     "Parallel Computing",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01678191/",
}

@Article{Verdu:2016:PSA,
  author =       "Javier Verdu and Alex Pajuelo",
  title =        "Performance Scalability Analysis of {JavaScript}
                 Applications with {Web Workers}",
  journal =      j-IEEE-COMPUT-ARCHIT-LETT,
  volume =       "15",
  number =       "2",
  pages =        "105--108",
  month =        jul # "\slash " # dec,
  year =         "2016",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1109/LCA.2015.2494585",
  ISSN =         "1556-6056 (print), 1556-6064 (electronic)",
  ISSN-L =       "1556-6056",
  bibdate =      "Thu Jun 20 17:18:18 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ieeecomputarchitlett.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "Web applications are getting closer to the performance
                 of native applications taking advantage of new
                 standard-based technologies. The recent HTML5 standard
                 includes, among others, the Web Workers API that allows
                 executing JavaScript applications on multiple threads,
                 or workers. However, the internals of the browser's
                 JavaScript virtual machine does not expose direct
                 relation between workers and running threads in the
                 browser and the utilization of logical cores in the
                 processor. As a result, developers do not know how
                 performance actually scales on different environments
                 and therefore what is the optimal number of workers on
                 parallel JavaScript codes. This paper presents the
                 first performance scalability analysis of parallel web
                 apps with multiple workers. We focus on two case
                 studies representative of different worker execution
                 models. Our analyses show performance scaling on
                 different parallel processor microarchitectures and on
                 three major web browsers in the market. Besides, we
                 study the impact of co-running applications on the web
                 app performance. The results provide insights for
                 future approaches to automatically find out the optimal
                 number of workers that provide the best tradeoff
                 between performance and resource usage to preserve
                 system responsiveness and user experience, especially
                 on environments with unexpected changes on system
                 workload.",
  acknowledgement = ack-nhfb,
  affiliation =  "Verdu, J (Reprint Author), BarcelonaTECH UPC, Dept
                 Comp Architecture, Barcelona, Spain. Verdu, Javier;
                 Pajuelo, Alex, BarcelonaTECH UPC, Dept Comp
                 Architecture, Barcelona, Spain.",
  author-email = "jverdu@ac.upc.edu mpajuelo@ac.upc.edu",
  da =           "2019-06-20",
  doc-delivery-number = "EH9MM",
  eissn =        "1556-6064",
  fjournal =     "IEEE Computer Architecture Letters",
  funding-acknowledgement = "Spanish Ministry of Economy and
                 Competitiveness (MINECO) [TIN2012-34557]",
  funding-text = "This work has been supported by the Spanish Ministry
                 of Economy and Competitiveness (MINECO) under contract
                 TIN2012-34557.",
  journal-iso =  "IEEE Comput. Archit. Lett.",
  journal-URL =  "http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=10208",
  keywords =     "HTML5; javascript; multithreading; parallelism; web
                 apps; web workers",
  number-of-cited-references = "12",
  oa =           "Green Published",
  ORCID-numbers = "Pajuelo, Alex/0000-0002-5510-6860 Verdu Mula,
                 Javier/0000-0003-4485-2419",
  research-areas = "Computer Science",
  times-cited =  "1",
  unique-id =    "Verdu:2016:PSA",
  web-of-science-categories = "Computer Science, Hardware \&
                 Architecture",
}

@Article{Vidal:2016:ECJ,
  author =       "S. Vidal and A. Bergel and J. A. D{\'\i}az-Pace and C.
                 Marcos",
  title =        "Over-exposed classes in {Java}: an empirical study",
  journal =      j-COMP-LANGS-SYS-STRUCT,
  volume =       "46",
  number =       "??",
  pages =        "1--19",
  month =        nov,
  year =         "2016",
  CODEN =        "????",
  ISSN =         "1477-8424 (print), 1873-6866 (electronic)",
  ISSN-L =       "1477-8424",
  bibdate =      "Thu Nov 17 09:48:26 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/complngs.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S1477842415300531",
  acknowledgement = ack-nhfb,
  fjournal =     "Computer Languages, Systems and Structures",
  journal-URL =  "http://www.sciencedirect.com/science/journal/14778424/",
}

@Article{Vidal:2016:UAE,
  author =       "Santiago A. Vidal and Alexandre Bergel and Claudia
                 Marcos and J. Andr{\'e}s D{\'\i}az-Pace",
  title =        "Understanding and addressing exhibitionism in {Java}
                 empirical research about method accessibility",
  journal =      j-EMPIR-SOFTWARE-ENG,
  volume =       "21",
  number =       "2",
  pages =        "483--516",
  month =        apr,
  year =         "2016",
  CODEN =        "ESENFW",
  DOI =          "https://doi.org/10.1007/s10664-015-9365-9",
  ISSN =         "1382-3256 (print), 1573-7616 (electronic)",
  ISSN-L =       "1382-3256",
  bibdate =      "Fri Dec 2 09:14:42 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/empir-software-eng.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://link.springer.com/accesspage/article/10.1007/s10664-015-9365-9",
  acknowledgement = ack-nhfb,
  fjournal =     "Empirical Software Engineering",
  journal-URL =  "http://link.springer.com/journal/10664",
}

@Article{Wei:2016:ESD,
  author =       "Shiyi Wei and Franceska Xhakaj and Barbara G. Ryder",
  title =        "Empirical study of the dynamic behavior of
                 {JavaScript} objects",
  journal =      j-SPE,
  volume =       "46",
  number =       "7",
  pages =        "867--889",
  month =        jul,
  year =         "2016",
  CODEN =        "SPEXBL",
  DOI =          "https://doi.org/10.1002/spe.2334",
  ISSN =         "0038-0644 (print), 1097-024X (electronic)",
  ISSN-L =       "0038-0644",
  bibdate =      "Wed Jun 8 07:13:23 MDT 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/spe.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Software --- Practice and Experience",
  journal-URL =  "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)1097-024X",
}

@Article{Wellings:2016:ISC,
  author =       "A. J. Wellings and V. Cholpanov and A. Burns",
  title =        "Implementing Safety-Critical {Java} Missions in
                 {Ada}",
  journal =      j-SIGADA-LETTERS,
  volume =       "36",
  number =       "1",
  pages =        "51--62",
  month =        jun,
  year =         "2016",
  CODEN =        "AALEE5",
  DOI =          "https://doi.org/10.1145/2971571.2971578",
  ISSN =         "0736-721X",
  bibdate =      "Thu Mar 16 15:40:54 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigada.bib",
  abstract =     "Critical systems written in Ada are still reluctant to
                 use dynamic memory allocation. The Ravenscar profile,
                 for example, prohibits the dynamic creation of tasks.
                 This is in spite of the availability of storage pools
                 and the strong compile-time checking of access types.
                 The Java community has, by necessity, taken a slightly
                 less conservative approach. Safety-Critical Java (SCJ)
                 supports a constrained use of dynamic memory
                 allocation. This paper takes the SCJ approach and tries
                 to implement it using Ada's storage pools. We show that
                 the approach is not directly transferable to Ada due to
                 the difference in the way that SCJ and Ada handle
                 region-based memory management. However, an equivalent
                 approach can be developed.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGADA Ada Letters",
  journal-URL =  "http://portal.acm.org/citation.cfm?id=J32",
}

@Article{Zhang:2016:NVC,
  author =       "Kebo Zhang and Hailing Xiong and Chao Li",
  title =        "A new version of code {Java} for {$3$D} simulation of
                 the {CCA} model",
  journal =      j-COMP-PHYS-COMM,
  volume =       "204",
  number =       "??",
  pages =        "214--215",
  month =        jul,
  year =         "2016",
  CODEN =        "CPHCBZ",
  ISSN =         "0010-4655 (print), 1879-2944 (electronic)",
  ISSN-L =       "0010-4655",
  bibdate =      "Fri May 13 19:25:21 MDT 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/compphyscomm2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0010465516300741",
  acknowledgement = ack-nhfb,
  fjournal =     "Computer Physics Communications",
  journal-URL =  "http://www.sciencedirect.com/science/journal/00104655/",
}

@Article{Zheng:2016:CMD,
  author =       "Yudi Zheng and Stephen Kell and Lubomir Bulej and
                 Haiyang Sun and Walter Binder",
  title =        "Comprehensive Multiplatform Dynamic Program Analysis
                 for {Java} and {Android}",
  journal =      j-IEEE-SOFTWARE,
  volume =       "33",
  number =       "4",
  pages =        "55--63",
  month =        jul # "\slash " # aug,
  year =         "2016",
  CODEN =        "IESOEG",
  ISSN =         "0740-7459 (print), 1937-4194 (electronic)",
  ISSN-L =       "0740-7459",
  bibdate =      "Thu Nov 17 07:49:10 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ieeesoft.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "https://www.computer.org/csdl/mags/so/2016/04/mso2016040055-abs.html",
  acknowledgement = ack-nhfb,
  journal-URL =  "http://www.computer.org/portal/web/csdl/magazines/software",
}

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

@Article{Zuo:2016:LOF,
  author =       "Zhiqiang Zuo and Lu Fang and Siau-Cheng Khoo and
                 Guoqing Xu and Shan Lu",
  title =        "Low-overhead and fully automated statistical debugging
                 with abstraction refinement",
  journal =      j-SIGPLAN,
  volume =       "51",
  number =       "10",
  pages =        "881--896",
  month =        oct,
  year =         "2016",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3022671.2984005",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:13 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Cooperative statistical debugging is an effective
                 approach for diagnosing production-run failures. To
                 quickly identify failure predictors from the huge
                 program predicate space, existing techniques rely on
                 random or heuristics-guided predicate sampling at the
                 user side. However, none of them can satisfy the
                 requirements of low cost, low diagnosis latency, and
                 high diagnosis quality simultaneously, which are all
                 indispensable for statistical debugging to be
                 practical. This paper presents a new technique that
                 tackles the above challenges. We formulate the
                 technique as an instance of abstraction refinement,
                 where efficient abstract-level profiling is first
                 applied to the whole program and its execution brings
                 information that can pinpoint suspicious coarse-grained
                 entities that need to be refined. The refinement
                 profiles a corresponding set of fine-grained entities,
                 and generates feedback that determines what to prune
                 and what to refine next. The process is fully
                 automated, and more importantly, guided by a
                 mathematically rigorous analysis that guarantees that
                 our approach produces the same debugging results as an
                 exhaustive analysis in deterministic settings. We have
                 implemented this technique for both C and Java on both
                 single machine and distributed system. A thorough
                 evaluation demonstrates that our approach yields (1) an
                 order of magnitude reduction in the user-side runtime
                 overhead even compared to a sampling-based approach and
                 (2) two orders of magnitude reduction in the size of
                 data transferred over the network, completely
                 automatically without sacrificing any debugging
                 capability.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "OOPSLA '16 conference proceedings.",
}

@Article{Adamsen:2017:PIR,
  author =       "Christoffer Quist Adamsen and Anders M{\o}ller and
                 Frank Tip",
  title =        "Practical initialization race detection for
                 {JavaScript} web applications",
  journal =      j-PACMPL,
  volume =       "1",
  number =       "OOPSLA",
  pages =        "66:1--66:??",
  month =        oct,
  year =         "2017",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/3133890",
  ISSN =         "2475-1421",
  bibdate =      "Wed Jan 10 09:45:26 MST 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/pacmpl.bib",
  acknowledgement = ack-nhfb,
  articleno =    "66",
  fjournal =     "Proceedings of the ACM on Programming Languages",
  journal-URL =  "https://pacmpl.acm.org/",
}

@Article{Andreasen:2017:SDA,
  author =       "Esben Andreasen and Liang Gong and Anders M{\o}ller
                 and Michael Pradel and Marija Selakovic and Koushik Sen
                 and Cristian-Alexandru Staicu",
  title =        "A Survey of Dynamic Analysis and Test Generation for
                 {JavaScript}",
  journal =      j-COMP-SURV,
  volume =       "50",
  number =       "5",
  pages =        "66:1--66:??",
  month =        nov,
  year =         "2017",
  CODEN =        "CMSVAN",
  DOI =          "https://doi.org/10.1145/3106739",
  ISSN =         "0360-0300 (print), 1557-7341 (electronic)",
  ISSN-L =       "0360-0300",
  bibdate =      "Sat Jan 20 09:25:00 MST 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/compsurv.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "JavaScript has become one of the most prevalent
                 programming languages. Unfortunately, some of the
                 unique properties that contribute to this popularity
                 also make JavaScript programs prone to errors and
                 difficult for program analyses to reason about. These
                 properties include the highly dynamic nature of the
                 language, a set of unusual language features, a lack of
                 encapsulation mechanisms, and the ``no crash''
                 philosophy. This article surveys dynamic program
                 analysis and test generation techniques for JavaScript
                 targeted at improving the correctness, reliability,
                 performance, security, and privacy of JavaScript-based
                 software.",
  acknowledgement = ack-nhfb,
  articleno =    "66",
  fjournal =     "ACM Computing Surveys",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J204",
}

@Article{Antonopoulos:2017:DIS,
  author =       "Timos Antonopoulos and Paul Gazzillo and Michael Hicks
                 and Eric Koskinen and Tachio Terauchi and Shiyi Wei",
  title =        "Decomposition instead of self-composition for proving
                 the absence of timing channels",
  journal =      j-SIGPLAN,
  volume =       "52",
  number =       "6",
  pages =        "362--375",
  month =        jun,
  year =         "2017",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3140587.3062378",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:17 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "We present a novel approach to proving the absence of
                 timing channels. The idea is to partition the program's
                 execution traces in such a way that each partition
                 component is checked for timing attack resilience by a
                 time complexity analysis and that per-component
                 resilience implies the resilience of the whole program.
                 We construct a partition by splitting the program
                 traces at secret-independent branches. This ensures
                 that any pair of traces with the same public input has
                 a component containing both traces. Crucially, the
                 per-component checks can be normal safety properties
                 expressed in terms of a single execution. Our approach
                 is thus in contrast to prior approaches, such as
                 self-composition, that aim to reason about multiple $
                 (k \geq 2) $ executions at once. We formalize the above
                 as an approach called quotient partitioning,
                 generalized to any k -safety property, and prove it to
                 be sound. A key feature of our approach is a
                 demand-driven partitioning strategy that uses a
                 regex-like notion called trails to identify sets of
                 execution traces, particularly those influenced by
                 tainted (or secret) data. We have applied our technique
                 in a prototype implementation tool called Blazer, based
                 on WALA, PPL, and the brics automaton library. We have
                 proved timing-channel freedom of (or synthesized an
                 attack specification for) 24 programs written in Java
                 bytecode, including 6 classic examples from the
                 literature and 6 examples extracted from the DARPA STAC
                 challenge problems.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "PLDI '17 conference proceedings.",
}

@Article{Arcaini:2017:RDP,
  author =       "Paolo Arcaini and Angelo Gargantini and Elvinia
                 Riccobene",
  title =        "Rigorous development process of a safety-critical
                 system: from {ASM} models to {Java} code",
  journal =      j-INT-J-SOFTW-TOOLS-TECHNOL-TRANSFER,
  volume =       "19",
  number =       "2",
  pages =        "247--269",
  month =        apr,
  year =         "2017",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1007/s10009-015-0394-x",
  ISSN =         "1433-2779 (print), 1433-2787 (electronic)",
  ISSN-L =       "1433-2779",
  bibdate =      "Mon Mar 13 16:18:14 MDT 2017",
  bibsource =    "http://link.springer.com/journal/10009/19/2;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sttt.bib",
  URL =          "http://link.springer.com/accesspage/article/10.1007/s10009-015-0394-x;
                 http://link.springer.com/article/10.1007/s10009-015-0394-x",
  acknowledgement = ack-nhfb,
  fjournal =     "International Journal on Software Tools for Technology
                 Transfer (STTT)",
  journal-URL =  "http://link.springer.com/journal/10009",
}

@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/java2010.bib;
                 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,
  articleno =    "10",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Badihi:2017:CAG,
  author =       "Sahar Badihi and Abbas Heydarnoori",
  title =        "{CrowdSummarizer}: Automated Generation of Code
                 Summaries for {Java} Programs through Crowdsourcing",
  journal =      j-IEEE-SOFTWARE,
  volume =       "34",
  number =       "2",
  pages =        "71--80",
  month =        mar # "\slash " # apr,
  year =         "2017",
  CODEN =        "IESOEG",
  DOI =          "https://doi.org/10.1109/MS.2017.45",
  ISSN =         "0740-7459 (print), 1937-4194 (electronic)",
  ISSN-L =       "0740-7459",
  bibdate =      "Tue Jul 25 21:43:46 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ieeesoft.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "https://www.computer.org/csdl/mags/so/2017/02/mso2017020071-abs.html",
  acknowledgement = ack-nhfb,
  journal-URL =  "http://www.computer.org/portal/web/csdl/magazines/software",
}

@Article{Basin:2017:KKV,
  author =       "Dmitry Basin and Edward Bortnikov and Anastasia
                 Braginsky and Guy Golan-Gueta and Eshcar Hillel and
                 Idit Keidar and Moshe Sulamy",
  title =        "{KiWi}: a Key--Value Map for Scalable Real-Time
                 Analytics",
  journal =      j-SIGPLAN,
  volume =       "52",
  number =       "8",
  pages =        "357--369",
  month =        aug,
  year =         "2017",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3155284.3018761",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Dec 1 18:56:12 MST 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Modern big data processing platforms employ huge
                 in-memory key--value (KV) maps. Their applications
                 simultaneously drive high-rate data ingestion and
                 large-scale analytics. These two scenarios expect
                 KV-map implementations that scale well with both
                 real-time updates and large atomic scans triggered by
                 range queries. We present KiWi, the first atomic KV-map
                 to efficiently support simultaneous large scans and
                 real-time access. The key to achieving this is treating
                 scans as first class citizens,and organizing the data
                 structure around them. KiWi provides wait-free scans,
                 whereas its put operations are lightweight and
                 lock-free. It optimizes memory management jointly with
                 data structure access.We implement KiWi and compare it
                 to state-of-the-art solutions. Compared to other
                 KV-maps providing atomic scans, KiWi performs either
                 long scans or concurrent puts an order of magnitude
                 faster. Its scans are twice as fast as non-atomic ones
                 implemented via iterators in the Java skiplist.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "PPoPP '17 conference proceedings.",
}

@Article{Battig:2017:SDC,
  author =       "Martin B{\"a}ttig and Thomas R. Gross",
  title =        "Synchronized-by-Default Concurrency for Shared-Memory
                 Systems",
  journal =      j-SIGPLAN,
  volume =       "52",
  number =       "8",
  pages =        "299--312",
  month =        aug,
  year =         "2017",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3155284.3018747",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Dec 1 18:56:12 MST 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "We explore a programming approach for concurrency that
                 synchronizes all accesses to shared memory by default.
                 Synchronization takes place by ensuring that all
                 program code runs inside atomic sections even if the
                 program code has external side effects. Threads are
                 mapped to atomic sections that a programmer must
                 explicitly split to increase concurrency. A naive
                 implementation of this approach incurs a large amount
                 of overhead. We show how to reduce this overhead to
                 make the approach suitable for realistic application
                 programs on existing hardware. We present an
                 implementation technique based on a special-purpose
                 software transactional memory system. To reduce the
                 overhead, the technique exploits properties of managed,
                 object-oriented programming languages as well as
                 intraprocedural static analyses and uses field-level
                 granularity locking in combination with transactional
                 I/O to provide good scaling properties. We implemented
                 the synchronized-by-default (SBD) approach for the Java
                 language and evaluate its performance for six programs
                 from the DaCapo benchmark suite. The evaluation shows
                 that, compared to explicit synchronization, the SBD
                 approach has an overhead between 0.4\% and 102\%
                 depending on the benchmark and the number of threads,
                 with a mean (geom.) of 23.9\%.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "PPoPP '17 conference proceedings.",
}

@Article{Berman:2017:EUS,
  author =       "Lewis Berman and Keith Gallagher and Suzanne
                 Kozaitis",
  title =        "Evaluating the Use of Sound in Static Program
                 Comprehension",
  journal =      j-TAP,
  volume =       "15",
  number =       "1",
  pages =        "7:1--7:??",
  month =        nov,
  year =         "2017",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/3129456",
  ISSN =         "1544-3558 (print), 1544-3965 (electronic)",
  ISSN-L =       "1544-3558",
  bibdate =      "Mon Jan 22 17:39:41 MST 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/tap.bib",
  abstract =     "Comprehension of computer programs is daunting, due in
                 part to clutter in the software developer's visual
                 environment and the need for frequent visual context
                 changes. Previous research has shown that nonspeech
                 sound can be useful in understanding the runtime
                 behavior of a program. We explore the viability and
                 advantages of using nonspeech sound in an ecological
                 framework to help understand the static structure of
                 software. We describe a novel concept for auditory
                 display of program elements in which sounds indicate
                 characteristics and relationships among a Java
                 program's classes, interfaces, and methods. An
                 empirical study employing this concept was used to
                 evaluate 24 sighted software professionals and students
                 performing maintenance-oriented tasks using a 2$ \times
                 $2 crossover. Viability is strong for differentiation
                 and characterization of software entities, less so for
                 identification. The results suggest that sonification
                 can be advantageous under certain conditions, though
                 they do not indicate the overall advantage of using
                 sound in terms of task duration at a 5\% level of
                 significance. The results uncover other findings such
                 as differences in comprehension strategy based on the
                 available tool environment. The participants reported
                 enthusiasm for the idea of software sonification,
                 mitigated by lack of familiarity with the concept and
                 the brittleness of the tool. Limitations of the present
                 research include restriction to particular types of
                 comprehension tasks, a single sound mapping, a single
                 programming language, and limited training time, but
                 the use of sound in program comprehension shows
                 sufficient promise for continued research.",
  acknowledgement = ack-nhfb,
  articleno =    "7",
  fjournal =     "ACM Transactions on Applied Perception (TAP)",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J932",
}

@Article{Bettini:2017:XTJ,
  author =       "Lorenzo Bettini and Ferruccio Damiani",
  title =        "{Xtraitj}: {Traits} for the {Java} platform",
  journal =      j-J-SYST-SOFTW,
  volume =       "131",
  number =       "??",
  pages =        "419--441",
  month =        sep,
  year =         "2017",
  CODEN =        "JSSODM",
  ISSN =         "0164-1212 (print), 1873-1228 (electronic)",
  ISSN-L =       "0164-1212",
  bibdate =      "Thu Jul 27 16:32:34 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/jsystsoftw.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0164121216301297",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Systems and Software",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01641212",
}

@Article{Biboudis:2017:RJD,
  author =       "Aggelos Biboudis and Pablo Inostroza and Tijs van der
                 Storm",
  title =        "{Recaf}: {Java} dialects as libraries",
  journal =      j-SIGPLAN,
  volume =       "52",
  number =       "3",
  pages =        "2--13",
  month =        mar,
  year =         "2017",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3093335.2993239",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:15 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Mainstream programming languages like Java have
                 limited support for language extensibility. Without
                 mechanisms for syntactic abstraction, new programming
                 styles can only be embedded in the form of libraries,
                 limiting expressiveness. In this paper, we present
                 Recaf, a lightweight tool for creating Java dialects;
                 effectively extending Java with new language constructs
                 and user defined semantics. The Recaf compiler
                 generically transforms designated method bodies to code
                 that is parameterized by a semantic factory (Object
                 Algebra), defined in plain Java. The implementation of
                 such a factory defines the desired runtime semantics.
                 We applied our design to produce several examples from
                 a diverse set of programming styles and two case
                 studies: we define (i) extensions for generators,
                 asynchronous computations and asynchronous streams and
                 (ii) a Domain-Specific Language (DSL) for Parsing
                 Expression Grammars (PEGs), in a few lines of code.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "GPCE '16 conference proceedings.",
}

@Article{Bliudze:2017:ECC,
  author =       "Simon Bliudze and Anastasia Mavridou and Radoslaw
                 Szymanek and Alina Zolotukhina",
  title =        "Exogenous coordination of concurrent software
                 components with {JavaBIP}",
  journal =      j-SPE,
  volume =       "47",
  number =       "11",
  pages =        "1801--1836",
  month =        nov,
  year =         "2017",
  CODEN =        "SPEXBL",
  DOI =          "https://doi.org/10.1002/spe.2495",
  ISSN =         "0038-0644 (print), 1097-024X (electronic)",
  ISSN-L =       "0038-0644",
  bibdate =      "Sat Dec 23 09:28:58 MST 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/spe.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Software --- Practice and Experience",
  journal-URL =  "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)1097-024X",
}

@Article{Bonetta:2017:FJF,
  author =       "Daniele Bonetta and Matthias Brantner",
  title =        "{FAD.js}: fast {JSON} data access using {JIT}-based
                 speculative optimizations",
  journal =      j-PROC-VLDB-ENDOWMENT,
  volume =       "10",
  number =       "12",
  pages =        "1778--1789",
  month =        aug,
  year =         "2017",
  CODEN =        "????",
  DOI =          "https://doi.org/10.14778/3137765.3137782",
  ISSN =         "2150-8097",
  bibdate =      "Tue Oct 10 17:16:19 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/vldbe.bib",
  abstract =     "JSON is one of the most popular data encoding formats,
                 with wide adoption in Databases and BigData frameworks
                 as well as native support in popular programming
                 languages such as JavaScript/Node.js, Python, and R.
                 Nevertheless, JSON data processing can easily become a
                 performance bottleneck in data-intensive applications
                 because of parse and serialization overhead. In this
                 paper, we introduce F ad.js, a runtime system for
                 efficient processing of JSON objects in data-intensive
                 applications. Fad.js is based on (1) speculative
                 just-in-time (JIT) compilation and (2) selective access
                 to data. Experiments show that applications using
                 Fad.js achieve speedups up to 2.7x for encoding and
                 9.9x for decoding JSON data when compared to
                 state-of-the art JSON processing libraries.",
  acknowledgement = ack-nhfb,
  fjournal =     "Proceedings of the VLDB Endowment",
  journal-URL =  "http://portal.acm.org/citation.cfm?id=J1174",
}

@Article{Briggs:2017:COI,
  author =       "Kim T. Briggs and Baoguo Zhou and Gerhard W. Dueck",
  title =        "Cold object identification in the {Java Virtual
                 Machine}",
  journal =      j-SPE,
  volume =       "47",
  number =       "1",
  pages =        "79--95",
  month =        jan,
  year =         "2017",
  CODEN =        "SPEXBL",
  DOI =          "https://doi.org/10.1002/spe.2396",
  ISSN =         "0038-0644 (print), 1097-024X (electronic)",
  ISSN-L =       "0038-0644",
  bibdate =      "Sat Feb 18 10:00:11 MST 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/spe.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Software --- Practice and Experience",
  journal-URL =  "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)1097-024X",
}

@Article{Brown:2017:NJP,
  author =       "Neil C. C. Brown and Amjad Altadmri",
  title =        "Novice {Java} Programming Mistakes: Large-Scale Data
                 vs. Educator Beliefs",
  journal =      j-TOCE,
  volume =       "17",
  number =       "2",
  pages =        "7:1--7:??",
  month =        jun,
  year =         "2017",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/2994154",
  ISSN =         "1946-6226",
  bibdate =      "Mon Aug 28 17:19:17 MDT 2017",
  bibsource =    "http://www.acm.org/pubs/toce;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/toce.bib",
  abstract =     "Teaching is the process of conveying knowledge and
                 skills to learners. It involves preventing
                 misunderstandings or correcting misconceptions that
                 learners have acquired. Thus, effective teaching relies
                 on solid knowledge of the discipline, but also a good
                 grasp of where learners are likely to trip up or
                 misunderstand. In programming, there is much
                 opportunity for misunderstanding, and the penalties are
                 harsh: failing to produce the correct syntax for a
                 program, for example, can completely prevent any
                 progress in learning how to program. Because
                 programming is inherently computer-based, we have an
                 opportunity to automatically observe programming
                 behaviour --- more closely even than an educator in the
                 room at the time. By observing students' programming
                 behaviour, and surveying educators, we can ask: do
                 educators have an accurate understanding of the
                 mistakes that students are likely to make? In this
                 study, we combined two years of the Blackbox dataset
                 (with more than 900 thousand users and almost 100
                 million compilation events) with a survey of 76
                 educators to investigate which mistakes students make
                 while learning to program Java, and whether the
                 educators could make an accurate estimate of which
                 mistakes were most common. We find that educators'
                 estimates do not agree with one another or the student
                 data, and discuss the implications of these results.",
  acknowledgement = ack-nhfb,
  articleno =    "7",
  fjournal =     "ACM Transactions on Computing Education",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J1193",
}

@Article{Bruno:2017:NPG,
  author =       "Rodrigo Bruno and Lu{\'\i}s Picciochi Oliveira and
                 Paulo Ferreira",
  title =        "{NG2C}: pretenuring garbage collection with dynamic
                 generations for {HotSpot} big data applications",
  journal =      j-SIGPLAN,
  volume =       "52",
  number =       "9",
  pages =        "2--13",
  month =        sep,
  year =         "2017",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3156685.3092272",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Dec 1 18:56:13 MST 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Big Data applications suffer from unpredictable and
                 unacceptably high pause times due to Garbage Collection
                 (GC). This is the case in latency-sensitive
                 applications such as on-line credit-card fraud
                 detection, graph-based computing for analysis on social
                 networks, etc. Such pauses compromise latency
                 requirements of the whole application stack and result
                 from applications' aggressive buffering/caching of
                 data, exposing an ill-suited GC design, which assumes
                 that most objects will die young and does not consider
                 that applications hold large amounts of middle-lived
                 data in memory. To avoid such pauses, we propose NG2C,
                 a new GC algorithm that combines pretenuring with
                 user-defined dynamic generations. By being able to
                 allocate objects into different generations, NG2C is
                 able to group objects with similar lifetime profiles in
                 the same generation. By allocating objects with similar
                 lifetime profiles close to each other, i.e. in the same
                 generation, we avoid object promotion (copying between
                 generations) and heap fragmentation (which leads to
                 heap compactions) both responsible for most of the
                 duration of HotSpot GC pause times. NG2C is implemented
                 for the OpenJDK 8 HotSpot Java Virtual Machine, as an
                 extension of the Garbage First GC. We evaluate NG2C
                 using Cassandra, Lucene, and GraphChi with three
                 different GCs: Garbage First (G1), Concurrent Mark
                 Sweep (CMS), and NG2C. Results show that NG2C decreases
                 the worst observable GC pause time by up to 94.8\% for
                 Cassandra, 85.0\% for Lucene and 96.45\% for GraphChi,
                 when compared to current collectors (G1 and CMS). In
                 addition, NG2c has no negative impact on application
                 throughput or memory usage.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "ISMM '17 conference proceedings.",
}

@Article{Canino:2017:PAE,
  author =       "Anthony Canino and Yu David Liu",
  title =        "Proactive and adaptive energy-aware programming with
                 mixed typechecking",
  journal =      j-SIGPLAN,
  volume =       "52",
  number =       "6",
  pages =        "217--232",
  month =        jun,
  year =         "2017",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3140587.3062356",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:17 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Application-level energy management is an important
                 dimension of energy optimization. In this paper, we
                 introduce ENT, a novel programming language for
                 enabling *proactive* and *adaptive* mode-based energy
                 management at the application level. The proactive
                 design allows programmers to apply their application
                 knowledge to energy management, by characterizing the
                 energy behavior of different program fragments with
                 modes. The adaptive design allows such characterization
                 to be delayed until run time, useful for capturing
                 dynamic program behavior dependent on program states,
                 configuration settings, external battery levels, or CPU
                 temperatures. The key insight is both proactiveness and
                 adaptiveness can be unified under a type system
                 combined with static typing and dynamic typing. ENT has
                 been implemented as an extension to Java, and
                 successfully ported to three energy-conscious
                 platforms: an Intel-based laptop, a Raspberry Pi, and
                 an Android phone. Evaluation shows ENT improves the
                 programmability, debuggability, and energy efficiency
                 of battery-aware and temperature-aware programs.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "PLDI '17 conference proceedings.",
}

@Article{Casale:2017:PEJ,
  author =       "Giuliano Casale and Giuseppe Serazzi and Lulai Zhu",
  title =        "Performance Evaluation with {Java} Modelling Tools: a
                 Hands-on Introduction",
  journal =      j-SIGMETRICS,
  volume =       "45",
  number =       "3",
  pages =        "246--247",
  month =        dec,
  year =         "2017",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/3199524.3199567",
  ISSN =         "0163-5999 (print), 1557-9484 (electronic)",
  ISSN-L =       "0163-5999",
  bibdate =      "Tue Apr 10 06:31:40 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigmetrics.bib",
  abstract =     "The goal of this tutorial is to introduce Java
                 Modelling Tools (JMT), an open source framework for
                 discrete-event simulation and analysis of queueing
                 networks, both product-form and extended, generalized
                 stochastic Petri nets (GSPNs), and queueing Petri nets
                 (QPNs). Thanks to a user-friendly graphical interface,
                 JMT is well-suited to teach performance modeling in
                 academia and to help research students familiarize with
                 classic modeling formalisms used in performance
                 evaluation. The tutorial introduces established and
                 novel features of the JMT suite and illustrates them on
                 case studies.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGMETRICS Performance Evaluation Review",
  journal-URL =  "http://portal.acm.org/toc.cfm?id=J618",
}

@Article{Castro:2017:JLC,
  author =       "Sergio Castro and Kim Mens and Paulo Moura",
  title =        "{JPC}: a library for categorising and applying
                 inter-language conversions between {Java} and
                 {Prolog}",
  journal =      j-SCI-COMPUT-PROGRAM,
  volume =       "134",
  number =       "??",
  pages =        "75--99",
  month =        "????",
  year =         "2017",
  CODEN =        "SCPGD4",
  ISSN =         "0167-6423 (print), 1872-7964 (electronic)",
  ISSN-L =       "0167-6423",
  bibdate =      "Thu Dec 1 16:49:54 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/scicomputprogram.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0167642315004049",
  acknowledgement = ack-nhfb,
  fjournal =     "Science of Computer Programming",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01676423/",
}

@Article{Chamberlain:2017:PLR,
  author =       "Scott Chamberlain and Jeffrey W. Hollister",
  title =        "\pkg{lawn}: An {R} client for the {Turf Javascript
                 Library for Geospatial Analysis}",
  journal =      j-J-OPEN-SOURCE-SOFT,
  volume =       "2",
  number =       "11",
  pages =        "194:1--194:1",
  month =        mar,
  year =         "2017",
  CODEN =        "????",
  DOI =          "https://doi.org/10.21105/joss.00194",
  ISSN =         "2475-9066",
  ISSN-L =       "2475-9066",
  bibdate =      "Thu Sep 13 08:09:35 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/joss.bib;
                 https://www.math.utah.edu/pub/tex/bib/s-plus.bib",
  URL =          "http://joss.theoj.org/papers/10.21105/joss.00194",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Open Source Software",
  journal-URL =  "http://joss.theoj.org/;
                 https://github.com/openjournals/joss-papers/",
  onlinedate =   "07 March 2017",
  ORCID-numbers = "Scott Chamberlain / 0000-0003-1444-9135; Jeffrey W.
                 Hollister / 0000-0002-9254-9740",
}

@Article{Chan:2017:DSL,
  author =       "Y. Chan and A. Wellings and I. Gray and N. Audsley",
  title =        "A Distributed Stream Library for {Java 8}",
  journal =      j-IEEE-TRANS-BIG-DATA,
  volume =       "3",
  number =       "3",
  pages =        "262--275",
  month =        sep,
  year =         "2017",
  DOI =          "https://doi.org/10.1109/TBDATA.2017.2666201",
  ISSN =         "2332-7790",
  bibdate =      "Fri Aug 2 11:24:47 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ieeetransbigdata.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE Transactions on Big Data",
  journal-URL =  "http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=6687317",
  keywords =     "application program interfaces; Big Data; Big data;
                 Big Data systems; Computational modeling; Data models;
                 data-parallel computing; distributed computing;
                 distributed stream library; Hadoop; Java; Java 8
                 Streams API; parallel processing; Pipelines;
                 Programming; programming models; Spark; Sparks",
}

@Article{Chaudhuri:2017:FPT,
  author =       "Avik Chaudhuri and Panagiotis Vekris and Sam Goldman
                 and Marshall Roch and Gabriel Levi",
  title =        "Fast and precise type checking for {JavaScript}",
  journal =      j-PACMPL,
  volume =       "1",
  number =       "OOPSLA",
  pages =        "48:1--48:??",
  month =        oct,
  year =         "2017",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/3133872",
  ISSN =         "2475-1421",
  bibdate =      "Wed Jan 10 09:45:26 MST 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/pacmpl.bib",
  acknowledgement = ack-nhfb,
  articleno =    "48",
  fjournal =     "Proceedings of the ACM on Programming Languages",
  journal-URL =  "https://pacmpl.acm.org/",
}

@Article{Chawdhary:2017:PES,
  author =       "Aziem Chawdhary and Ranjeet Singh and Andy King",
  title =        "Partial evaluation of string obfuscations for {Java}
                 malware detection",
  journal =      j-FORM-ASP-COMPUT,
  volume =       "29",
  number =       "1",
  pages =        "33--55",
  month =        jan,
  year =         "2017",
  CODEN =        "FACME5",
  DOI =          "https://doi.org/10.1007/s00165-016-0357-3",
  ISSN =         "0934-5043 (print), 1433-299X (electronic)",
  ISSN-L =       "0934-5043",
  bibdate =      "Sat Mar 11 16:42:14 MST 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/formaspcomput.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://link.springer.com/accesspage/article/10.1007/s00165-016-0357-3;
                 http://link.springer.com/article/10.1007/s00165-016-0357-3",
  acknowledgement = ack-nhfb,
  fjournal =     "Formal Aspects of Computing",
  journal-URL =  "http://link.springer.com/journal/165",
}

@Article{Chen:2017:CLP,
  author =       "Boyuan Chen and Zhen Ming (Jack) Jiang",
  title =        "Characterizing logging practices in {Java}-based open
                 source software projects --- a replication study in
                 {Apache Software Foundation}",
  journal =      j-EMPIR-SOFTWARE-ENG,
  volume =       "22",
  number =       "1",
  pages =        "330--374",
  month =        feb,
  year =         "2017",
  CODEN =        "ESENFW",
  DOI =          "https://doi.org/10.1007/s10664-016-9429-5",
  ISSN =         "1382-3256 (print), 1573-7616 (electronic)",
  ISSN-L =       "1382-3256",
  bibdate =      "Mon Mar 13 15:08:57 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/empir-software-eng.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://link.springer.com/accesspage/article/10.1007/s10664-016-9429-5",
  acknowledgement = ack-nhfb,
  fjournal =     "Empirical Software Engineering",
  journal-URL =  "http://link.springer.com/journal/10664",
}

@Article{Chisnall:2017:CJS,
  author =       "David Chisnall and Brooks Davis and Khilan Gudka and
                 David Brazdil and Alexandre Joannou and Jonathan
                 Woodruff and A. Theodore Markettos and J. Edward Maste
                 and Robert Norton and Stacey Son and Michael Roe and
                 Simon W. Moore and Peter G. Neumann and Ben Laurie and
                 Robert N. M. Watson",
  title =        "{CHERI JNI}: Sinking the {Java} Security Model into
                 the {C}",
  journal =      j-COMP-ARCH-NEWS,
  volume =       "45",
  number =       "1",
  pages =        "569--583",
  month =        mar,
  year =         "2017",
  CODEN =        "CANED2",
  DOI =          "https://doi.org/10.1145/3093337.3037725",
  ISSN =         "0163-5964 (print), 1943-5851 (electronic)",
  ISSN-L =       "0163-5964",
  bibdate =      "Mon Jun 5 18:01:58 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigarch.bib",
  abstract =     "Java provides security and robustness by building a
                 high-level security model atop the foundation of memory
                 protection. Unfortunately, any native code linked into
                 a Java program --- including the million lines used to
                 implement the standard library --- is able to bypass
                 both the memory protection and the higher-level
                 policies. We present a hardware-assisted implementation
                 of the Java native code interface, which extends the
                 guarantees required for Java's security model to native
                 code. Our design supports safe direct access to buffers
                 owned by the JVM, including hardware-enforced read-only
                 access where appropriate. We also present Java language
                 syntax to declaratively describe isolated compartments
                 for native code. We show that it is possible to
                 preserve the memory safety and isolation requirements
                 of the Java security model in C code, allowing native
                 code to run in the same process as Java code with the
                 same impact on security as running equivalent Java
                 code. Our approach has a negligible impact on
                 performance, compared with the existing unsafe native
                 code interface. We demonstrate a prototype
                 implementation running on the CHERI microprocessor
                 synthesized in FPGA.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGARCH Computer Architecture News",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J89",
  remark =       "ASPLOS'17 conference proceedings",
}

@Article{Choi:2017:SAS,
  author =       "Jiho Choi and Thomas Shull and Maria J. Garzaran and
                 Josep Torrellas",
  title =        "{ShortCut}: Architectural Support for Fast Object
                 Access in Scripting Languages",
  journal =      j-COMP-ARCH-NEWS,
  volume =       "45",
  number =       "2",
  pages =        "494--506",
  month =        may,
  year =         "2017",
  CODEN =        "CANED2",
  DOI =          "https://doi.org/10.1145/3140659.3080237",
  ISSN =         "0163-5964 (print), 1943-5851 (electronic)",
  ISSN-L =       "0163-5964",
  bibdate =      "Fri Sep 15 11:09:14 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigarch.bib",
  abstract =     "The same flexibility that makes dynamic scripting
                 languages appealing to programmers is also the primary
                 cause of their low performance. To access objects of
                 potentially different types, the compiler creates a
                 dispatcher with a series of if statements, each
                 performing a comparison to a type and a jump to a
                 handler. This induces major overhead in instructions
                 executed and branches mispredicted. This paper proposes
                 architectural support to significantly improve the
                 efficiency of accesses to objects. The idea is to
                 modify the instruction that calls the dispatcher so
                 that, under most conditions, it skips most of the
                 branches and instructions needed to reach the correct
                 handler, and sometimes even the execution of the
                 handler itself. Our novel architecture, called
                 ShortCut, performs two levels of optimization. Its
                 Plain design transforms the call to the dispatcher into
                 a call to the correct handler --- bypassing the whole
                 dispatcher execution. Its Aggressive design transforms
                 the call to the dispatcher into a simple load or store
                 --- bypassing the execution of both dispatcher and
                 handler. We implement the ShortCut software in the
                 state-of-the-art Google V8 JIT compiler, and the
                 ShortCut hardware in a simulator. We evaluate ShortCut
                 with the Octane and SunSpider JavaScript application
                 suites. Plain ShortCut reduces the average execution
                 time of the applications by 30\% running under the
                 baseline compiler, and by 11\% running under the
                 maximum level of compiler optimization. Aggressive
                 ShortCut performs only slightly better.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGARCH Computer Architecture News",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J89",
}

@Book{Dannen:2017:IES,
  author =       "Chris Dannen",
  title =        "Introducing {Ethereum} and Solidity",
  publisher =    "Apress",
  address =      "Brooklyn, NY",
  pages =        "xxi + 185",
  year =         "2017",
  DOI =          "https://doi.org/10.1007/978-1-4842-2535-6",
  ISBN =         "1-4842-2535-X",
  ISBN-13 =      "978-1-4842-2535-6",
  bibdate =      "Thu Nov 30 15:51:20 MST 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/bitcoin.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://link.springer.com/book/10.1007/978-1-4842-2535-6",
  abstract =     "Learn how to use Solidity and the Ethereum project ---
                 second only to Bitcoin in market capitalization.
                 Blockchain protocols are taking the world by storm, and
                 the Ethereum project, with its Turing-complete
                 scripting language Solidity, has rapidly become a
                 front-runner. This book presents the blockchain
                 phenomenon in context; then situates Ethereum in a
                 world pioneered by Bitcoin. See why professionals and
                 non-professionals alike are honing their skills in
                 smart contract patterns and distributed application
                 development. You'll review the fundamentals of
                 programming and networking, alongside its introduction
                 to the new discipline of crypto-economics. You'll then
                 deploy smart contracts of your own, and learn how they
                 can serve as a back-end for JavaScript and HTML
                 applications on the Web. Many Solidity tutorials out
                 there today have the same flaw: they are written
                 for``advanced'' JavaScript developers who want to
                 transfer their skills to a blockchain environment.
                 Introducing Ethereum and Solidity is accessible to
                 technology professionals and enthusiasts of ``all
                 levels.'' You'll find exciting sample code that can
                 move forward real world assets in both the academic and
                 the corporate arenas. Find out now why this book is a
                 powerful gateway for creative technologists of all
                 types, from concept to deployment.",
  acknowledgement = ack-nhfb,
  tableofcontents = "At a Glance \\
                 Contents \\
                 About the Author \\
                 About the Technical Reviewer \\
                 Chapter 1: Bridging the Blockchain Knowledge Gap \\
                 Blockchain Roll Call! \\
                 What Ethereum Does \\
                 Three Parts of a Blockchain \\
                 Ethereum Assumes Many Chains \\
                 This Is a Scam, Just Like Bitcoin! \\
                 Ether as a Currency and Commodity \\
                 Gresham's Law \\
                 The Path to Better Money \\
                 Cryptoeconomics and Security \\
                 Back to the Good Old Days \\
                 Cryptochaos \\
                 The Power Is in the Protocol \\
                 You Can Build Trustless Systems \\
                 What Smart Contracts (Really) Do \\
                 Objects and Methods for Value \\
                 Just Add Commerce \\
                 Content Creation \\
                 Where's the Data?What Is Mining?Ether and Electricity
                 Prices \\
                 Going Inside the EVM \\
                 The Mist Browser \\
                 Browser vs. Wallet or Keychain \\
                 Solidity Is Kind of Like JavaScript, But and What
                 Ethereum Is Good For \\
                 A Critical Take \\
                 ``Without any possibility of downtime, censorship, or
                 third-party interference'' \\
                 ``A secure, free, and open platform for the Internet of
                 Things'' \\
                 ``Enabling transparent governance for communities and
                 businesses'' \\
                 ``Handles user authentication and secure payments for
                 you, as well as messaging and even decentralized
                 storage'' \\
                 ``No need to sign up or pay for application host: The
                 world's first zero-infrastructure platform'' \\
                 State of Smart Contract Development Today \\
                 Copycat Coins \\
                 Funding Your Project \\
                 Deciding Where You Fit In \\
                 A Note to New Programmers \\
                 Ethereum Is Free and Open Source \\
                 The EVM Is Here to Stay \\
                 What You Can Build Today \\
                 Private and Public Chains \\
                 Send and Receive Ether \\
                 Write Smart Contracts \\
                 Create Provably Fair Applications \\
                 Launch Your Own Token \\
                 The Promise of Decentralized Databases \\
                 What's Next: New Ways of Working \\
                 Summary \\
                 Chapter 2: The Mist Browser \\
                 Wallets as a Computing Metaphor \\
                 Your Address Is What? \\
                 Where Is My Ether? The Bank Teller Metaphor \\
                 In Cryptocurrency, You Hold Your Own Assets \\
                 Visualizing Ethereum Transactions \\
                 Breaking with Banking History \\
                 How Encryption Leads to Trust \\
                 System Requirements \\
                 More about Eth.guide and This Book \\
                 Tools for Developers \\
                 CLI Nodes \\
                 Recommended: Using Parity with Geth \\
                 Finally, into the Mist! \\
                 Downloading and Installing Mist \\
                 Configuring Mist \\
                 Finding Your New Address \\
                 Sending and Receiving Ether \\
                 Understanding Ethereum Account Types \\
                 Backing Up and Restoring Your Keys \\
                 Using Paper Wallets \\
                 Using Mobile Wallets \\
                 Working with Messages and Transactions \\
                 Transactions Change State \\
                 Editing a Global Database \\
                 So, What Is a Blockchain? \\
                 Paying for Transactions \\
                 Understanding Denominations \\
                 Getting Ether \\
                 Anonymity in Cryptocurrency \\
                 Blockchain Explorers \\
                 Summary \\
                 Chapter 3: The EVM \\
                 The Central Bank Network of Yesterday \\
                 What are Virtual Machines, Exactly? \\
                 The Role of the Ethereum Protocol in Banking \\
                 Anyone Can Make a Banking Platform \\
                 What the EVM Does \\
                 EVM Applications Are Called Smart Contracts \\
                 The Name ``Smart Contracts'' \\
                 The EVM Runs Bytecode \\
                 Understanding State Machines \\
                 Digital vs. Analog \\
                 ``State-ments'' \\
                 Data's Role in State",
}

@Article{DeBeukelaer:2017:ECP,
  author =       "Herman {De Beukelaer} and Guy F. Davenport and Geert
                 {De Meyer} and Veerle Fack",
  title =        "Extended Conference Paper: {JAMES}: an object-oriented
                 {Java} framework for discrete optimization using local
                 search metaheuristics",
  journal =      j-SPE,
  volume =       "47",
  number =       "6",
  pages =        "921--938",
  month =        jun,
  year =         "2017",
  CODEN =        "SPEXBL",
  DOI =          "https://doi.org/10.1002/spe.2459",
  ISSN =         "0038-0644 (print), 1097-024X (electronic)",
  ISSN-L =       "0038-0644",
  bibdate =      "Mon Jul 24 08:17:12 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/spe.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Software --- Practice and Experience",
  journal-URL =  "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)1097-024X",
}

@Article{Fernandes:2017:AUM,
  author =       "Leonardo Fernandes and M{\'a}rcio Ribeiro and Luiz
                 Carvalho and Rohit Gheyi and Melina Mongiovi and
                 Andr{\'e} Santos and Ana Cavalcanti and Fabiano Ferrari
                 and Jos{\'e} Carlos Maldonado",
  title =        "Avoiding useless mutants",
  journal =      j-SIGPLAN,
  volume =       "52",
  number =       "12",
  pages =        "187--198",
  month =        dec,
  year =         "2017",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3170492.3136053",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Dec 1 18:56:14 MST 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Mutation testing is a program-transformation technique
                 that injects artificial bugs to check whether the
                 existing test suite can detect them. However, the costs
                 of using mutation testing are usually high, hindering
                 its use in industry. Useless mutants (equivalent and
                 duplicated) contribute to increase costs. Previous
                 research has focused mainly on detecting useless
                 mutants only after they are generated and compiled. In
                 this paper, we introduce a strategy to help developers
                 with deriving rules to avoid the generation of useless
                 mutants. To use our strategy, we pass as input a set of
                 programs. For each program, we also need a passing test
                 suite and a set of mutants. As output, our strategy
                 yields a set of useless mutants candidates. After
                 manually confirming that the mutants classified by our
                 strategy as ``useless'' are indeed useless, we derive
                 rules that can avoid their generation and thus decrease
                 costs. To the best of our knowledge, we introduce 37
                 new rules that can avoid useless mutants right before
                 their generation. We then implement a subset of these
                 rules in the MUJAVA mutation testing tool. Since our
                 rules have been derived based on artificial and small
                 Java programs, we take our MUJAVA version embedded with
                 our rules and execute it in industrial-scale projects.
                 Our rules reduced the number of mutants by almost 13\%
                 on average. Our results are promising because (i) we
                 avoid useless mutants generation; (ii) our strategy can
                 help with identifying more rules in case we set it to
                 use more complex Java programs; and (iii) our MUJAVA
                 version has only a subset of the rules we derived.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "GPCE '17 conference proceedings.",
}

@Article{Ferrari:2017:JJF,
  author =       "Mauro Ferrari and Camillo Fiorentini and Guido
                 Fiorino",
  title =        "{JTabWb}: a {Java} Framework for Implementing
                 Terminating Sequent and Tableau Calculi",
  journal =      j-FUND-INFO,
  volume =       "150",
  number =       "1",
  pages =        "119--142",
  month =        "????",
  year =         "2017",
  CODEN =        "FUMAAJ",
  DOI =          "https://doi.org/10.3233/FI-2017-1462",
  ISSN =         "0169-2968 (print), 1875-8681 (electronic)",
  ISSN-L =       "0169-2968",
  bibdate =      "Sat Mar 11 09:46:15 MST 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/fundinfo2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Fundamenta Informaticae",
  journal-URL =  "http://content.iospress.com/journals/fundamenta-informaticae",
}

@Article{Fetter:2017:TJT,
  author =       "Mirko Fetter and David Bimamisa and Tom Gross",
  title =        "{TUIOFX}: a {JavaFX} Toolkit for Shared Interactive
                 Surfaces",
  journal =      j-PACMHCI,
  volume =       "1",
  number =       "EICS",
  pages =        "10:1--10:18",
  month =        jun,
  year =         "2017",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/3095812",
  ISSN =         "2573-0142 (electronic)",
  ISSN-L =       "2573-0142",
  bibdate =      "Wed Mar 31 06:23:42 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/pacmhci.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3095812",
  abstract =     "Building multi-touch multi-user applications for
                 Shared Interactive Surfaces is a complex endeavour that
                 requires fundamental knowledge in touch enabling
                 hardware, gesture recognition, graphical representation
                 of \ldots{}",
  acknowledgement = ack-nhfb,
  articleno =    "10",
  fjournal =     "Proceedings of the ACM on Human-Computer Interaction
                 (PACMHCI)",
  journal-URL =  "https://dl.acm.org/loi/pacmhci",
}

@Article{Foley-Bourgon:2017:EIC,
  author =       "Vincent Foley-Bourgon and Laurie Hendren",
  title =        "Efficiently implementing the copy semantics of
                 {MATLAB}'s arrays in {JavaScript}",
  journal =      j-SIGPLAN,
  volume =       "52",
  number =       "2",
  pages =        "72--83",
  month =        feb,
  year =         "2017",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3093334.2989235",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:15 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/matlab.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Compiling MATLAB---a dynamic, array-based
                 language---to JavaScript is an attractive proposal: the
                 output code can be deployed on a platform used by
                 billions and can leverage the countless hours that have
                 gone into making JavaScript JIT engines fast. But
                 before that can happen, the original MATLAB code must
                 be properly translated, making sure to bridge the
                 semantic gaps of the two languages. An important area
                 where MATLAB and JavaScript differ is in their handling
                 of arrays: for example, in MATLAB, arrays are
                 one-indexed and writing at an index beyond the end of
                 an array extends it; in JavaScript, typed arrays are
                 zero-indexed and writing out of bounds is a no-op. A
                 MATLAB-to-JavaScript compiler must address these
                 mismatches. Another salient and pervasive difference
                 between the two languages is the assignment of arrays
                 to variables: in MATLAB, this operation has value
                 semantics, while in JavaScript is has reference
                 semantics. In this paper, we present MatJuice --- a
                 source-to-source, ahead-of-time compiler back-end for
                 MATLAB --- and how it deals efficiently with this last
                 issue. We present an intra-procedural data-flow
                 analysis to track where each array variable may point
                 to and which variables are possibly aliased. We also
                 present the associated copy insertion transformation
                 that uses the points-to information to insert explicit
                 copies when necessary. The resulting JavaScript program
                 respects the MATLAB value semantics and we show that it
                 performs fewer run-time copies than some alternative
                 approaches.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "DLS '16 conference proceedings.",
}

@Article{Fox:2017:EJT,
  author =       "Geoffrey Fox",
  title =        "Editorials: {Java Technologies for Real-Time and
                 Embedded Systems (JTRES2013)}",
  journal =      j-CCPE,
  volume =       "29",
  number =       "6",
  pages =        "??--??",
  day =          "25",
  month =        mar,
  year =         "2017",
  CODEN =        "CCPEBO",
  DOI =          "https://doi.org/10.1002/cpe.4089",
  ISSN =         "1532-0626 (print), 1532-0634 (electronic)",
  ISSN-L =       "1532-0626",
  bibdate =      "Fri Mar 31 19:12:51 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Concurrency and Computation: Practice and Experience",
  journal-URL =  "http://www.interscience.wiley.com/jpages/1532-0626",
}

@Article{Fox:2017:ESI,
  author =       "Geoffrey Fox",
  title =        "Editorial: Special issue on {12th international
                 workshop on Java technologies for real-time and
                 embedded systems (JTRES2014)}",
  journal =      j-CCPE,
  volume =       "29",
  number =       "22",
  pages =        "??--??",
  day =          "25",
  month =        nov,
  year =         "2017",
  CODEN =        "CCPEBO",
  DOI =          "https://doi.org/10.1002/cpe.4353",
  ISSN =         "1532-0626 (print), 1532-0634 (electronic)",
  ISSN-L =       "1532-0626",
  bibdate =      "Sat Dec 30 09:11:59 MST 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Concurrency and Computation: Practice and Experience",
  journal-URL =  "http://www.interscience.wiley.com/jpages/1532-0626",
}

@Article{Fritz:2017:TSA,
  author =       "Eric Fritz and Tian Zhao",
  title =        "Typing and semantics of asynchronous arrows in
                 {JavaScript}",
  journal =      j-SCI-COMPUT-PROGRAM,
  volume =       "141--142",
  number =       "??",
  pages =        "1--39",
  month =        jul # "\slash " # aug,
  year =         "2017",
  CODEN =        "SCPGD4",
  ISSN =         "0167-6423 (print), 1872-7964 (electronic)",
  ISSN-L =       "0167-6423",
  bibdate =      "Wed Jul 26 05:56:43 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/scicomputprogram.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0167642317300527",
  acknowledgement = ack-nhfb,
  fjournal =     "Science of Computer Programming",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01676423",
}

@Article{Golan-Gueta:2017:ASA,
  author =       "Guy Golan-Gueta and G. Ramalingam and Mooly Sagiv and
                 Eran Yahav",
  title =        "Automatic Scalable Atomicity via Semantic Locking",
  journal =      j-TOPC,
  volume =       "3",
  number =       "4",
  pages =        "21:1--21:??",
  month =        mar,
  year =         "2017",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/3040223",
  ISSN =         "2329-4949 (print), 2329-4957 (electronic)",
  ISSN-L =       "2329-4949",
  bibdate =      "Sat Mar 25 07:55:06 MDT 2017",
  bibsource =    "http://topc.acm.org/;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/topc.bib",
  abstract =     "In this article, we consider concurrent programs in
                 which the shared state consists of instances of
                 linearizable abstract data types (ADTs). We present an
                 automated approach to concurrency control that
                 addresses a common need: the need to atomically execute
                 a code fragment, which may contain multiple ADT
                 operations on multiple ADT instances. We present a
                 synthesis algorithm that automatically enforces
                 atomicity of given code fragments (in a client program)
                 by inserting pessimistic synchronization that
                 guarantees atomicity and deadlock-freedom (without
                 using any rollback mechanism). Our algorithm takes a
                 commutativity specification as an extra input. This
                 specification indicates for every pair of ADT
                 operations the conditions under which the operations
                 commute. Our algorithm enables greater parallelism by
                 permitting commuting operations to execute
                 concurrently. We have implemented the synthesis
                 algorithm in a Java compiler and applied it to several
                 Java programs. Our results show that our approach
                 produces efficient and scalable synchronization.",
  acknowledgement = ack-nhfb,
  articleno =    "21",
  fjournal =     "ACM Transactions on Parallel Computing",
  journal-URL =  "http://dl.acm.org/citation.cfm?id=2632163",
}

@Article{Grigore:2017:JGT,
  author =       "Radu Grigore",
  title =        "{Java} generics are {Turing} complete",
  journal =      j-SIGPLAN,
  volume =       "52",
  number =       "1",
  pages =        "73--85",
  month =        jan,
  year =         "2017",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3093333.3009871",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:14 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "This paper describes a reduction from the halting
                 problem of Turing machines to subtype checking in Java.
                 It follows that subtype checking in Java is
                 undecidable, which answers a question posed by Kennedy
                 and Pierce in 2007. It also follows that Java's type
                 checker can recognize any recursive language, which
                 improves a result of Gill and Levy from 2016. The
                 latter point is illustrated by a parser generator for
                 fluent interfaces.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "POPL '17 conference proceedings.",
}

@Article{Guo:2017:MJF,
  author =       "Robert Guo",
  title =        "{MongoDB}'s {JavaScript} fuzzer",
  journal =      j-CACM,
  volume =       "60",
  number =       "5",
  pages =        "43--47",
  month =        may,
  year =         "2017",
  CODEN =        "CACMA2",
  DOI =          "https://doi.org/10.1145/3052937",
  ISSN =         "0001-0782 (print), 1557-7317 (electronic)",
  ISSN-L =       "0001-0782",
  bibdate =      "Sat May 27 15:08:46 MDT 2017",
  bibsource =    "http://www.acm.org/pubs/contents/journals/cacm/;
                 https://www.math.utah.edu/pub/tex/bib/cacm2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://cacm.acm.org/magazines/2017/5/216320/fulltext",
  abstract =     "The fuzzer is for those edge cases that your testing
                 did not catch.",
  acknowledgement = ack-nhfb,
  fjournal =     "Communications of the ACM",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J79",
}

@Article{Haas:2017:BWS,
  author =       "Andreas Haas and Andreas Rossberg and Derek L. Schuff
                 and Ben L. Titzer and Michael Holman and Dan Gohman and
                 Luke Wagner and Alon Zakai and JF Bastien",
  title =        "Bringing the web up to speed with {WebAssembly}",
  journal =      j-SIGPLAN,
  volume =       "52",
  number =       "6",
  pages =        "185--200",
  month =        jun,
  year =         "2017",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3140587.3062363",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:17 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "The maturation of the Web platform has given rise to
                 sophisticated and demanding Web applications such as
                 interactive 3D visualization, audio and video software,
                 and games. With that, efficiency and security of code
                 on the Web has become more important than ever. Yet
                 JavaScript as the only built-in language of the Web is
                 not well-equipped to meet these requirements,
                 especially as a compilation target. Engineers from the
                 four major browser vendors have risen to the challenge
                 and collaboratively designed a portable low-level
                 bytecode called WebAssembly. It offers compact
                 representation, efficient validation and compilation,
                 and safe low to no-overhead execution. Rather than
                 committing to a specific programming model, WebAssembly
                 is an abstraction over modern hardware, making it
                 language-, hardware-, and platform-independent, with
                 use cases beyond just the Web. WebAssembly has been
                 designed with a formal semantics from the start. We
                 describe the motivation, design and formal semantics of
                 WebAssembly and provide some preliminary experience
                 with implementations.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "PLDI '17 conference proceedings.",
}

@Article{Halder:2017:JSV,
  author =       "Prithish Halder and Himadri Sekhar Das",
  title =        "{JaSTA-2}: Second version of the {Java Superposition
                 T-matrix Application}",
  journal =      j-COMP-PHYS-COMM,
  volume =       "221",
  number =       "??",
  pages =        "421--422",
  month =        dec,
  year =         "2017",
  CODEN =        "CPHCBZ",
  ISSN =         "0010-4655 (print), 1879-2944 (electronic)",
  ISSN-L =       "0010-4655",
  bibdate =      "Mon Oct 16 14:20:16 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/compphyscomm2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0010465517302667",
  acknowledgement = ack-nhfb,
  fjournal =     "Computer Physics Communications",
  journal-URL =  "http://www.sciencedirect.com/science/journal/00104655",
}

@Article{Hammer:2017:VOV,
  author =       "Matthew A. Hammer and Bor-Yuh Evan Chang and David
                 {Van Horn}",
  title =        "A vision for online verification-validation",
  journal =      j-SIGPLAN,
  volume =       "52",
  number =       "3",
  pages =        "190--201",
  month =        mar,
  year =         "2017",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3093335.2993255",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:15 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Today's programmers face a false choice between
                 creating software that is extensible and software that
                 is correct. Specifically, dynamic languages permit
                 software that is richly extensible (via dynamic code
                 loading, dynamic object extension, and various forms of
                 reflection), and today's programmers exploit this
                 flexibility to ``bring their own language features'' to
                 enrich extensible languages (e.g., by using common
                 JavaScript libraries). Meanwhile, such library-based
                 language extensions generally lack enforcement of their
                 abstractions, leading to programming errors that are
                 complex to avoid and predict. To offer verification for
                 this extensible world, we propose online
                 verification-validation (OVV), which consists of
                 language and VM design that enables a ``phaseless''
                 approach to program analysis, in contrast to the
                 standard static-dynamic phase distinction. Phaseless
                 analysis freely interposes abstract interpretation with
                 concrete execution, allowing analyses to use dynamic
                 (concrete) information to prove universal (abstract)
                 properties about future execution. In this paper, we
                 present a conceptual overview of OVV through a
                 motivating example program that uses a hypothetical
                 database library. We present a generic semantics for
                 OVV, and an extension to this semantics that offers a
                 simple gradual type system for the database library
                 primitives. The result of instantiating this gradual
                 type system in an OVV setting is a checker that can
                 progressively type successive continuations of the
                 program until a continuation is fully verified. To
                 evaluate the proposed vision of OVV for this example,
                 we implement the VM semantics (in Rust), and show that
                 this design permits progressive typing in this
                 manner.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "GPCE '16 conference proceedings.",
}

@Article{Hanazumi:2017:FAI,
  author =       "Simone Hanazumi and Ana C. V. de Melo",
  title =        "A formal approach to implement {Java} exceptions in
                 cooperative systems",
  journal =      j-J-SYST-SOFTW,
  volume =       "131",
  number =       "??",
  pages =        "475--490",
  month =        sep,
  year =         "2017",
  CODEN =        "JSSODM",
  ISSN =         "0164-1212 (print), 1873-1228 (electronic)",
  ISSN-L =       "0164-1212",
  bibdate =      "Thu Jul 27 16:32:34 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/jsystsoftw.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0164121216301285",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Systems and Software",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01641212",
}

@Article{Jayaraman:2017:CVJ,
  author =       "S. Jayaraman and B. Jayaraman and D. Lessa",
  title =        "Compact visualization of {Java} program execution",
  journal =      j-SPE,
  volume =       "47",
  number =       "2",
  pages =        "163--191",
  month =        feb,
  year =         "2017",
  CODEN =        "SPEXBL",
  DOI =          "https://doi.org/10.1002/spe.2411",
  ISSN =         "0038-0644 (print), 1097-024X (electronic)",
  ISSN-L =       "0038-0644",
  bibdate =      "Sat Feb 18 10:00:11 MST 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/spe.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Software --- Practice and Experience",
  journal-URL =  "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)1097-024X",
}

@Article{Kang:2017:PSR,
  author =       "Jeehoon Kang and Chung-Kil Hur and Ori Lahav and
                 Viktor Vafeiadis and Derek Dreyer",
  title =        "A promising semantics for relaxed-memory concurrency",
  journal =      j-SIGPLAN,
  volume =       "52",
  number =       "1",
  pages =        "175--189",
  month =        jan,
  year =         "2017",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3093333.3009850",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:14 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Despite many years of research, it has proven very
                 difficult to develop a memory model for concurrent
                 programming languages that adequately balances the
                 conflicting desiderata of programmers, compilers, and
                 hardware. In this paper, we propose the first relaxed
                 memory model that (1) accounts for a broad spectrum of
                 features from the C++11 concurrency model, (2) is
                 implementable, in the sense that it provably validates
                 many standard compiler optimizations and reorderings,
                 as well as standard compilation schemes to x86-TSO and
                 Power, (3) justifies simple invariant-based reasoning,
                 thus demonstrating the absence of bad
                 ``out-of-thin-air'' behaviors, (4) supports ``DRF''
                 guarantees, ensuring that programmers who use
                 sufficient synchronization need not understand the full
                 complexities of relaxed-memory semantics, and (5)
                 defines the semantics of racy programs without relying
                 on undefined behaviors, which is a prerequisite for
                 applicability to type-safe languages like Java. The key
                 novel idea behind our model is the notion of
                 *promises*: a thread may promise to execute a write in
                 the future, thus enabling other threads to read from
                 that write out of order. Crucially, to prevent
                 out-of-thin-air behaviors, a promise step requires a
                 thread-local certification that it will be possible to
                 execute the promised write even in the absence of the
                 promise. To establish confidence in our model, we have
                 formalized most of our key results in Coq.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "POPL '17 conference proceedings.",
}

@Article{Kedia:2017:SFS,
  author =       "Piyus Kedia and Manuel Costa and Matthew Parkinson and
                 Kapil Vaswani and Dimitrios Vytiniotis and Aaron
                 Blankstein",
  title =        "Simple, fast, and safe manual memory management",
  journal =      j-SIGPLAN,
  volume =       "52",
  number =       "6",
  pages =        "233--247",
  month =        jun,
  year =         "2017",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3140587.3062376",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:17 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Safe programming languages are readily available, but
                 many applications continue to be written in unsafe
                 languages because of efficiency. As a consequence, many
                 applications continue to have exploitable memory safety
                 bugs. Since garbage collection is a major source of
                 inefficiency in the implementation of safe languages,
                 replacing it with safe manual memory management would
                 be an important step towards solving this problem.
                 Previous approaches to safe manual memory management
                 use programming models based on regions, unique
                 pointers, borrowing of references, and ownership types.
                 We propose a much simpler programming model that does
                 not require any of these concepts. Starting from the
                 design of an imperative type safe language (like Java
                 or C\#), we just add a delete operator to free memory
                 explicitly and an exception which is thrown if the
                 program dereferences a pointer to freed memory. We
                 propose an efficient implementation of this programming
                 model that guarantees type safety. Experimental results
                 from our implementation based on the C\# native
                 compiler show that this design achieves up to 3x
                 reduction in peak working set and run time.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "PLDI '17 conference proceedings.",
}

@Article{Kim:2017:TAA,
  author =       "Channoh Kim and Jaehyeok Kim and Sungmin Kim and
                 Dooyoung Kim and Namho Kim and Gitae Na and Young H. Oh
                 and Hyeon Gyu Cho and Jae W. Lee",
  title =        "Typed Architectures: Architectural Support for
                 Lightweight Scripting",
  journal =      j-COMP-ARCH-NEWS,
  volume =       "45",
  number =       "1",
  pages =        "77--90",
  month =        mar,
  year =         "2017",
  CODEN =        "CANED2",
  DOI =          "https://doi.org/10.1145/3093337.3037726",
  ISSN =         "0163-5964 (print), 1943-5851 (electronic)",
  ISSN-L =       "0163-5964",
  bibdate =      "Mon Jun 5 18:01:58 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigarch.bib",
  abstract =     "Dynamic scripting languages are becoming more and more
                 widely adopted not only for fast prototyping but also
                 for developing production-grade applications. They
                 provide high-productivity programming environments
                 featuring high levels of abstraction with powerful
                 built-in functions, automatic memory management,
                 object-oriented programming paradigm and dynamic
                 typing. However, their flexible, dynamic type systems
                 easily become the source of inefficiency in terms of
                 instruction count, memory footprint, and energy
                 consumption. This overhead makes it challenging to
                 deploy these high-productivity programming technologies
                 on emerging single-board computers for IoT
                 applications. Addressing this challenge, this paper
                 introduces Typed Architectures, a high-efficiency,
                 low-cost execution substrate for dynamic scripting
                 languages, where each data variable retains high-level
                 type information at an ISA level. Typed Architectures
                 calculate and check the dynamic type of each variable
                 implicitly in hardware, rather than explicitly in
                 software, hence significantly reducing instruction
                 count for dynamic type checking. Besides, Typed
                 Architectures introduce polymorphic instructions (e.g.,
                 xadd), which are bound to the correct native
                 instruction at runtime within the pipeline (e.g., add
                 or fadd) to efficiently implement polymorphic
                 operators. Finally, Typed Architectures provide
                 hardware support for flexible yet efficient type tag
                 extraction and insertion, capturing common data layout
                 patterns of tag-value pairs. Our evaluation using a
                 fully synthesizable RISC-V RTL design on FPGA shows
                 that Typed Architectures achieve geomean speedups of
                 11.2\% and 9.9\% with maximum speedups of 32.6\% and
                 43.5\% for two production-grade scripting engines for
                 JavaScript and Lua, respectively. Moreover, Typed
                 Architectures improve the energy-delay product (EDP) by
                 19.3\% for JavaScript and 16.5\% for Lua with an area
                 overhead of 1.6\% at a 40nm technology node.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGARCH Computer Architecture News",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J89",
  remark =       "ASPLOS'17 conference proceedings",
}

@Article{Kiselyov:2017:SFC,
  author =       "Oleg Kiselyov and Aggelos Biboudis and Nick Palladinos
                 and Yannis Smaragdakis",
  title =        "Stream fusion, to completeness",
  journal =      j-SIGPLAN,
  volume =       "52",
  number =       "1",
  pages =        "285--299",
  month =        jan,
  year =         "2017",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3093333.3009880",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:14 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Stream processing is mainstream (again): Widely-used
                 stream libraries are now available for virtually all
                 modern OO and functional languages, from Java to C\# to
                 Scala to OCaml to Haskell. Yet expressivity and
                 performance are still lacking. For instance, the
                 popular, well-optimized Java 8 streams do not support
                 the zip operator and are still an order of magnitude
                 slower than hand-written loops. We present the first
                 approach that represents the full generality of stream
                 processing and eliminates overheads, via the use of
                 staging. It is based on an unusually rich semantic
                 model of stream interaction. We support any combination
                 of zipping, nesting (or flat-mapping), sub-ranging,
                 filtering, mapping-of finite or infinite streams. Our
                 model captures idiosyncrasies that a programmer uses in
                 optimizing stream pipelines, such as rate differences
                 and the choice of a ``for'' vs. ``while'' loops. Our
                 approach delivers hand-written-like code, but
                 automatically. It explicitly avoids the reliance on
                 black-box optimizers and sufficiently-smart compilers,
                 offering highest, guaranteed and portable performance.
                 Our approach relies on high-level concepts that are
                 then readily mapped into an implementation.
                 Accordingly, we have two distinct implementations: an
                 OCaml stream library, staged via MetaOCaml, and a Scala
                 library for the JVM, staged via LMS. In both cases, we
                 derive libraries richer and simultaneously many tens of
                 times faster than past work. We greatly exceed in
                 performance the standard stream libraries available in
                 Java, Scala and OCaml, including the well-optimized
                 Java 8 streams.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "POPL '17 conference proceedings.",
}

@Article{Kunjir:2017:TAM,
  author =       "Mayuresh Kunjir and Shivnath Babu",
  title =        "{Thoth} in action: memory management in modern data
                 analytics",
  journal =      j-PROC-VLDB-ENDOWMENT,
  volume =       "10",
  number =       "12",
  pages =        "1917--1920",
  month =        aug,
  year =         "2017",
  CODEN =        "????",
  DOI =          "https://doi.org/10.14778/3137765.3137808",
  ISSN =         "2150-8097",
  bibdate =      "Tue Oct 10 17:16:19 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/vldbe.bib",
  abstract =     "Allocation and usage of memory in modern
                 data-processing platforms is based on an interplay of
                 algorithms at multiple levels: (i) at the
                 resource-management level across containers allocated
                 by resource managers like Mesos and Yarn, (ii) at the
                 container level among the OS and processes such as the
                 Java Virtual Machine (JVM), (iii) at the framework
                 level for caching, aggregation, data shuffles, and
                 application data structures, and (iv) at the JVM level
                 across various pools such as the Young and Old
                 Generation as well as the heap versus off-heap. We use
                 Thoth, a data-driven platform for multi-system cluster
                 management, to build a deep understanding of different
                 interplays in memory management options. Through
                 multiple memory management apps built in Thoth, we
                 demonstrate how Thoth can deal with multiple levels of
                 memory management as well as multi-tenant nature of
                 clusters.",
  acknowledgement = ack-nhfb,
  fjournal =     "Proceedings of the VLDB Endowment",
  journal-URL =  "http://portal.acm.org/citation.cfm?id=J1174",
}

@Article{Landman:2017:CEA,
  author =       "Davy Landman and Alexander Serebrenik and Eric Bouwers
                 and Jurgen Vinju",
  title =        "Corrigendum: Empirical analysis of the relationship
                 between {CC} and {SLOC} in a large corpus of {Java}
                 methods and {C} functions published on {9 December
                 2015}",
  journal =      j-J-SOFTW-EVOL-PROC,
  volume =       "29",
  number =       "10",
  pages =        "??--??",
  month =        oct,
  year =         "2017",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1002/smr.1914",
  ISSN =         "2047-7473 (print), 2047-7481 (electronic)",
  ISSN-L =       "2047-7473",
  bibdate =      "Wed Jan 31 13:48:45 MST 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/jsoftwevolproc.bib",
  note =         "See \cite{Landman:2016:EAR}.",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Software: Evolution and Process",
  journal-URL =  "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)2047-7481",
}

@Article{Leijen:2017:TDC,
  author =       "Daan Leijen",
  title =        "Type directed compilation of row-typed algebraic
                 effects",
  journal =      j-SIGPLAN,
  volume =       "52",
  number =       "1",
  pages =        "486--499",
  month =        jan,
  year =         "2017",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3093333.3009872",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:14 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Algebraic effect handlers, introduced by Plotkin and
                 Power in 2002, are recently gaining in popularity as a
                 purely functional approach to modeling effects. In this
                 article, we give a full overview of practical algebraic
                 effects in the context of a compiled implementation in
                 the Koka language. In particular, we show how algebraic
                 effects generalize over common constructs like
                 exception handling, state, iterators and async-await.
                 We give an effective type inference algorithm based on
                 extensible effect rows using scoped labels, and a
                 direct operational semantics. Finally, we show an
                 efficient compilation scheme to common runtime
                 platforms (like JavaScript) using a type directed
                 selective CPS translation.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "POPL '17 conference proceedings.",
}

@Article{Loring:2017:SAJ,
  author =       "Matthew C. Loring and Mark Marron and Daan Leijen",
  title =        "Semantics of asynchronous {JavaScript}",
  journal =      j-SIGPLAN,
  volume =       "52",
  number =       "11",
  pages =        "51--62",
  month =        nov,
  year =         "2017",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3170472.3133846",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Dec 1 18:56:13 MST 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "JavaScript code running in the Node.js runtime is a
                 major platform for developers building cloud, mobile,
                 or IoT applications. A fundamental concept in Node.js
                 programming is the use of asynchronous callbacks and
                 event loops to provide highly responsive applications.
                 While conceptually simple, this programming model
                 contains numerous subtleties and behaviors that are
                 defined implicitly by the current Node.js
                 implementation. This paper presents the first
                 comprehensive formalization of the Node.js asynchronous
                 execution model and defines a high-level notion of
                 async-contexts to formalize fundamental relationships
                 between asynchronous executions in an application.
                 These formalizations provide a foundation for the
                 construction of static or dynamic program analysis
                 tools, support the exploration of alternative Node.js
                 event loop implementations, and provide a high-level
                 conceptual framework for reasoning about relationships
                 between the execution of asynchronous callbacks in a
                 Node.js application.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "DLS '17 conference proceedings.",
}

@Article{Luckcuck:2017:SCJ,
  author =       "Matt Luckcuck and Andy Wellings and Ana Cavalcanti",
  title =        "{Safety-Critical Java}: level 2 in practice",
  journal =      j-CCPE,
  volume =       "29",
  number =       "6",
  pages =        "??--??",
  day =          "25",
  month =        mar,
  year =         "2017",
  CODEN =        "CCPEBO",
  DOI =          "https://doi.org/10.1002/cpe.3951",
  ISSN =         "1532-0626 (print), 1532-0634 (electronic)",
  ISSN-L =       "1532-0626",
  bibdate =      "Fri Mar 31 19:12:51 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Concurrency and Computation: Practice and Experience",
  journal-URL =  "http://www.interscience.wiley.com/jpages/1532-0626",
}

@Article{Luckow:2017:HTP,
  author =       "Kasper S{\o}e Luckow and Bent Thomsen and Stephan Erbs
                 Korsholm",
  title =        "{HVM$_{TP}$}: a time predictable and portable {Java
                 Virtual Machine} for hard real-time embedded systems",
  journal =      j-CCPE,
  volume =       "29",
  number =       "22",
  pages =        "??--??",
  day =          "25",
  month =        nov,
  year =         "2017",
  CODEN =        "CCPEBO",
  DOI =          "https://doi.org/10.1002/cpe.3828",
  ISSN =         "1532-0626 (print), 1532-0634 (electronic)",
  ISSN-L =       "1532-0626",
  bibdate =      "Sat Dec 30 09:11:59 MST 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Concurrency and Computation: Practice and Experience",
  journal-URL =  "http://www.interscience.wiley.com/jpages/1532-0626",
}

@Article{Madsen:2017:MRA,
  author =       "Magnus Madsen and Ondrej Lhot{\'a}k and Frank Tip",
  title =        "A model for reasoning about {JavaScript} promises",
  journal =      j-PACMPL,
  volume =       "1",
  number =       "OOPSLA",
  pages =        "86:1--86:??",
  month =        oct,
  year =         "2017",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/3133910",
  ISSN =         "2475-1421",
  bibdate =      "Wed Jan 10 09:45:26 MST 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/pacmpl.bib",
  acknowledgement = ack-nhfb,
  articleno =    "86",
  fjournal =     "Proceedings of the ACM on Programming Languages",
  journal-URL =  "https://pacmpl.acm.org/",
}

@Article{Malhotra:2017:PPS,
  author =       "Geetika Malhotra and Rajshekar Kalayappan and Seep
                 Goel and Pooja Aggarwal and Abhishek Sagar and Smruti
                 R. Sarangi",
  title =        "{ParTejas}: a Parallel Simulator for Multicore
                 Processors",
  journal =      j-TOMACS,
  volume =       "27",
  number =       "3",
  pages =        "19:1--19:??",
  month =        sep,
  year =         "2017",
  CODEN =        "ATMCEZ",
  DOI =          "https://doi.org/10.1145/3077582",
  ISSN =         "1049-3301 (print), 1558-1195 (electronic)",
  ISSN-L =       "1049-3301",
  bibdate =      "Fri Sep 8 08:36:06 MDT 2017",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tomacs/;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/tomacs.bib",
  abstract =     "In this article, we present the design of a novel
                 parallel architecture simulator called ParTejas.
                 ParTejas is a timing simulation engine that gets its
                 execution traces from instrumented binaries using a
                 fast shared-memory-based mechanism. Subsequently, the
                 waiting threads simulate the execution of multiple
                 pipelines and an elaborate memory system with support
                 for multilevel coherent caches. ParTejas is written in
                 Java and primarily derives its speedups from the use of
                 novel data structures. Specifically, it uses lock-free
                 slot schedulers to design an entity called a parallel
                 port that effectively models the contention at shared
                 resources in the CPU and memory system. Parallel ports
                 remove the need for fine-grained synchronization and
                 allow each thread to use its local clock. Unlike
                 conventional simulators that use barriers for
                 synchronization at epoch boundaries, we use a
                 sophisticated type of barrier, known as a phaser. A
                 phaser allows threads to perform additional work
                 without waiting for other threads to arrive at the
                 barrier. Additionally, we use a host of Java-specific
                 optimizations and use profiling to effectively schedule
                 the threads. With all our optimizations, we demonstrate
                 a speedup of 11.8$ \times $ for a multi-issue in-order
                 pipeline and 10.9$ \times $ for an out-of-order
                 pipeline with 64 threads, for a suite of seven Splash2
                 and Parsec benchmarks. The simulation error is limited
                 to 2\% to 4\% as compared to strictly sequential
                 simulation",
  acknowledgement = ack-nhfb,
  articleno =    "19",
  fjournal =     "ACM Transactions on Modeling and Computer Simulation",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J781",
}

@Article{Mamouras:2017:SMS,
  author =       "Konstantinos Mamouras and Mukund Raghothaman and
                 Rajeev Alur and Zachary G. Ives and Sanjeev Khanna",
  title =        "{StreamQRE}: modular specification and efficient
                 evaluation of quantitative queries over streaming
                 data",
  journal =      j-SIGPLAN,
  volume =       "52",
  number =       "6",
  pages =        "693--708",
  month =        jun,
  year =         "2017",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3140587.3062369",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:17 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Real-time decision making in emerging IoT applications
                 typically relies on computing quantitative summaries of
                 large data streams in an efficient and incremental
                 manner. To simplify the task of programming the desired
                 logic, we propose StreamQRE, which provides natural and
                 high-level constructs for processing streaming data.
                 Our language has a novel integration of linguistic
                 constructs from two distinct programming paradigms:
                 streaming extensions of relational query languages and
                 quantitative extensions of regular expressions. The
                 former allows the programmer to employ relational
                 constructs to partition the input data by keys and to
                 integrate data streams from different sources, while
                 the latter can be used to exploit the logical hierarchy
                 in the input stream for modular specifications. We
                 first present the core language with a small set of
                 combinators, formal semantics, and a decidable type
                 system. We then show how to express a number of common
                 patterns with illustrative examples. Our compilation
                 algorithm translates the high-level query into a
                 streaming algorithm with precise complexity bounds on
                 per-item processing time and total memory footprint. We
                 also show how to integrate approximation algorithms
                 into our framework. We report on an implementation in
                 Java, and evaluate it with respect to existing
                 high-performance engines for processing streaming data.
                 Our experimental evaluation shows that (1) StreamQRE
                 allows more natural and succinct specification of
                 queries compared to existing frameworks, (2) the
                 throughput of our implementation is higher than
                 comparable systems (for example, two-to-four times
                 greater than RxJava), and (3) the approximation
                 algorithms supported by our implementation can lead to
                 substantial memory savings.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "PLDI '17 conference proceedings.",
}

@Article{Marr:2017:CLC,
  author =       "Stefan Marr and Benoit Daloze and Hanspeter
                 M{\"o}ssenb{\"o}ck",
  title =        "Cross-language compiler benchmarking: are we fast
                 yet?",
  journal =      j-SIGPLAN,
  volume =       "52",
  number =       "2",
  pages =        "120--131",
  month =        feb,
  year =         "2017",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3093334.2989232",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:15 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Comparing the performance of programming languages is
                 difficult because they differ in many aspects including
                 preferred programming abstractions, available
                 frameworks, and their runtime systems. Nonetheless, the
                 question about relative performance comes up repeatedly
                 in the research community, industry, and wider audience
                 of enthusiasts. This paper presents 14 benchmarks and a
                 novel methodology to assess the compiler effectiveness
                 across language implementations. Using a set of common
                 language abstractions, the benchmarks are implemented
                 in Java, JavaScript, Ruby, Crystal, Newspeak, and
                 Smalltalk. We show that the benchmarks exhibit a wide
                 range of characteristics using language-agnostic
                 metrics. Using four different languages on top of the
                 same compiler, we show that the benchmarks perform
                 similarly and therefore allow for a comparison of
                 compiler effectiveness across languages. Based on
                 anecdotes, we argue that these benchmarks help language
                 implementers to identify performance bugs and
                 optimization potential by comparing to other language
                 implementations.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "DLS '16 conference proceedings.",
}

@Article{Martinez:2017:ARR,
  author =       "Matias Martinez and Thomas Durieux and Romain
                 Sommerard and Jifeng Xuan and Martin Monperrus",
  title =        "Automatic repair of real bugs in {Java}: a large-scale
                 experiment on the {\tt defects4j} dataset",
  journal =      j-EMPIR-SOFTWARE-ENG,
  volume =       "22",
  number =       "4",
  pages =        "1936--1964",
  month =        aug,
  year =         "2017",
  CODEN =        "ESENFW",
  DOI =          "https://doi.org/10.1007/s10664-016-9470-4",
  ISSN =         "1382-3256 (print), 1573-7616 (electronic)",
  ISSN-L =       "1382-3256",
  bibdate =      "Mon Oct 2 11:35:01 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/empir-software-eng.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://link.springer.com/article/10.1007/s10664-016-9470-4",
  acknowledgement = ack-nhfb,
  fjournal =     "Empirical Software Engineering",
  journal-URL =  "http://link.springer.com/journal/10664",
}

@Article{Martinez:2017:MBA,
  author =       "Salvador Mart{\'\i}nez and Valerio Cosentino and Jordi
                 Cabot",
  title =        "Model-based analysis of {Java EE} web security
                 misconfigurations",
  journal =      j-COMP-LANGS-SYS-STRUCT,
  volume =       "49",
  number =       "??",
  pages =        "36--61",
  month =        sep,
  year =         "2017",
  CODEN =        "????",
  ISSN =         "1477-8424 (print), 1873-6866 (electronic)",
  ISSN-L =       "1477-8424",
  bibdate =      "Fri Sep 15 11:36:13 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/complngs.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S1477842416301348",
  acknowledgement = ack-nhfb,
  fjournal =     "Computer Languages, Systems and Structures",
  journal-URL =  "http://www.sciencedirect.com/science/journal/14778424/",
}

@Article{Martinsen:2017:CTL,
  author =       "Jan Kasper Martinsen and H{\aa}kan Grahn and Anders
                 Isberg",
  title =        "Combining thread-level speculation and just-in-time
                 compilation in {Google's V8 JavaScript} engine",
  journal =      j-CCPE,
  volume =       "29",
  number =       "1",
  pages =        "??--??",
  day =          "10",
  month =        jan,
  year =         "2017",
  CODEN =        "CCPEBO",
  DOI =          "https://doi.org/10.1002/cpe.3826",
  ISSN =         "1532-0626 (print), 1532-0634 (electronic)",
  ISSN-L =       "1532-0626",
  bibdate =      "Sat Feb 18 10:07:18 MST 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Concurrency and Computation: Practice and Experience",
  journal-URL =  "http://www.interscience.wiley.com/jpages/1532-0626",
}

@Article{Mazinanian:2017:UUL,
  author =       "Davood Mazinanian and Ameya Ketkar and Nikolaos
                 Tsantalis and Danny Dig",
  title =        "Understanding the use of lambda expressions in
                 {Java}",
  journal =      j-PACMPL,
  volume =       "1",
  number =       "OOPSLA",
  pages =        "85:1--85:??",
  month =        oct,
  year =         "2017",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/3133909",
  ISSN =         "2475-1421",
  bibdate =      "Wed Jan 10 09:45:26 MST 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/pacmpl.bib",
  acknowledgement = ack-nhfb,
  articleno =    "85",
  fjournal =     "Proceedings of the ACM on Programming Languages",
  journal-URL =  "https://pacmpl.acm.org/",
}

@Article{Mesbah:2017:REJ,
  author =       "Abdelhak Mesbah and Jean-Louis Lanet and Mohamed
                 Mezghiche",
  title =        "Reverse engineering a {Java Card} memory management
                 algorithm",
  journal =      j-COMPUT-SECUR,
  volume =       "66",
  number =       "??",
  pages =        "97--114",
  month =        may,
  year =         "2017",
  CODEN =        "CPSEDU",
  ISSN =         "0167-4048 (print), 1872-6208 (electronic)",
  ISSN-L =       "0167-4048",
  bibdate =      "Mon Sep 23 09:46:49 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/computsecur2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "https://www.sciencedirect.com/science/article/pii/S0167404817300093",
  acknowledgement = ack-nhfb,
  fjournal =     "Computers \& Security",
  journal-URL =  "https://www.sciencedirect.com/science/journal/01674048",
}

@Article{Nicolay:2017:PAJ,
  author =       "Jens Nicolay and Quentin Sti{\'e}venart and Wolfgang
                 {De Meuter} and Coen {De Roover}",
  title =        "Purity analysis for {JavaScript} through abstract
                 interpretation",
  journal =      j-J-SOFTW-EVOL-PROC,
  volume =       "29",
  number =       "12",
  pages =        "??--??",
  month =        dec,
  year =         "2017",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1002/smr.1889",
  ISSN =         "2047-7473 (print), 2047-7481 (electronic)",
  ISSN-L =       "2047-7473",
  bibdate =      "Wed Jan 31 13:48:46 MST 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/jsoftwevolproc.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Software: Evolution and Process",
  journal-URL =  "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)2047-7481",
}

@Article{Noller:2017:SSE,
  author =       "Yannic Noller and Hoang Lam Nguyen and Minxing Tang
                 and Timo Kehrer",
  title =        "Shadow Symbolic Execution with {Java PathFinder}",
  journal =      j-SIGSOFT,
  volume =       "42",
  number =       "4",
  pages =        "1--5",
  month =        oct,
  year =         "2017",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/3149485.3149492",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:16:48 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  abstract =     "Regression testing ensures that a software system when
                 it evolves still performs correctly and that the
                 changes introduce no unintended side-effects. However,
                 the creation of regression test cases that show
                 divergent behavior needs a lot of effort. A solution is
                 the idea of shadow symbolic execution, originally
                 implemented based on KLEE for programs written in C,
                 which takes a unified version of the old and the new
                 program and performs symbolic execution guided by
                 concrete values to explore the changed behavior. In
                 this work, we apply the idea of shadow symbolic
                 execution to Java programs and, hence, provide an
                 extension of the Java PathFinder (JPF) project to
                 perform shadow symbolic execution on Java bytecode. The
                 extension has been applied on several subjects from the
                 JPF test classes where it successfully generated test
                 inputs that expose divergences relevant for regression
                 testing.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Ocariza:2017:SCC,
  author =       "F. S. Ocariza and K. Bajaj and K. Pattabiraman and A.
                 Mesbah",
  title =        "A Study of Causes and Consequences of Client-Side
                 {JavaScript} Bugs",
  journal =      j-IEEE-TRANS-SOFTW-ENG,
  volume =       "43",
  number =       "2",
  pages =        "128--144",
  month =        feb,
  year =         "2017",
  CODEN =        "IESEDJ",
  DOI =          "https://doi.org/10.1109/TSE.2016.2586066",
  ISSN =         "0098-5589 (print), 1939-3520 (electronic)",
  ISSN-L =       "0098-5589",
  bibdate =      "Thu Feb 1 19:49:24 MST 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ieeetranssoftweng2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=7501855",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE Transactions on Software Engineering",
  journal-URL =  "http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=32",
}

@Article{Omar:2017:PSF,
  author =       "Cyrus Omar and Jonathan Aldrich",
  title =        "Programmable semantic fragments: the design and
                 implementation of {\tt typy}",
  journal =      j-SIGPLAN,
  volume =       "52",
  number =       "3",
  pages =        "81--92",
  month =        mar,
  year =         "2017",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3093335.2993245",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:15 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "This paper introduces typy, a statically typed
                 programming language embedded by reflection into
                 Python. typy features a fragmentary semantics, i.e. it
                 delegates semantic control over each term, drawn from
                 Python's fixed concrete and abstract syntax, to some
                 contextually relevant user-defined semantic fragment.
                 The delegated fragment programmatically (1) typechecks
                 the term (following a bidirectional protocol); and (2)
                 assigns dynamic meaning to the term by computing a
                 translation to Python. We argue that this design is
                 expressive with examples of fragments that express the
                 static and dynamic semantics of (1) functional records;
                 (2) labeled sums (with nested pattern matching a la
                 ML); (3) a variation on JavaScript's prototypal object
                 system; and (4) typed foreign interfaces to Python and
                 OpenCL. These semantic structures are, or would need to
                 be, defined primitively in conventionally structured
                 languages. We further argue that this design is
                 compositionally well-behaved. It avoids the expression
                 problem and the problems of grammar composition because
                 the syntax is fixed. Moreover, programs are
                 semantically stable under fragment composition (i.e.
                 defining a new fragment will not change the meaning of
                 existing program components.)",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "GPCE '16 conference proceedings.",
}

@Article{Pan:2017:GCF,
  author =       "Y. Pan and J. White and Y. Sun and J. Gray",
  title =        "Gray Computing: A Framework for Computing with
                 Background {JavaScript} Tasks",
  journal =      j-IEEE-TRANS-SOFTW-ENG,
  volume =       "PP",
  number =       "99",
  pages =        "1--1",
  month =        "????",
  year =         "2017",
  CODEN =        "IESEDJ",
  DOI =          "https://doi.org/10.1109/TSE.2017.2772812",
  ISSN =         "0098-5589 (print), 1939-3520 (electronic)",
  ISSN-L =       "0098-5589",
  bibdate =      "Thu Feb 1 19:49:24 MST 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ieeetranssoftweng2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=8105894",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE Transactions on Software Engineering",
  journal-URL =  "http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=32",
}

@Article{Park:2017:PSS,
  author =       "Changhee Park and Hyeonseung Im and Sukyoung Ryu",
  title =        "Precise and scalable static analysis of {jQuery} using
                 a regular expression domain",
  journal =      j-SIGPLAN,
  volume =       "52",
  number =       "2",
  pages =        "25--36",
  month =        feb,
  year =         "2017",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3093334.2989228",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:15 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "jQuery is the most popular JavaScript library but the
                 state-of-the-art static analyzers for JavaScript
                 applications fail to analyze simple programs that use
                 jQuery. In this paper, we present a novel abstract
                 string domain whose elements are simple regular
                 expressions that can represent prefix, infix, and
                 postfix substrings of a string and even their sets. We
                 formalize the new domain in the abstract interpretation
                 framework with abstract models of strings and objects
                 commonly used in the existing JavaScript analyzers. For
                 practical use of the domain, we present polynomial-time
                 inclusion decision rules between the regular
                 expressions and prove that the rules exactly capture
                 the actual inclusion relation. We have implemented the
                 domain as an extension of the open-source JavaScript
                 analyzer, SAFE, and we show that the extension
                 significantly improves the scalability and precision of
                 the baseline analyzer in analyzing programs that use
                 jQuery.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "DLS '16 conference proceedings.",
}

@Article{Philips:2017:DDD,
  author =       "Laure Philips and Joeri {De Koster} and Wolfgang {De
                 Meuter} and Coen {De Roover}",
  title =        "Dependence-driven delimited {CPS} transformation for
                 {JavaScript}",
  journal =      j-SIGPLAN,
  volume =       "52",
  number =       "3",
  pages =        "59--69",
  month =        mar,
  year =         "2017",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3093335.2993243",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:15 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "In today's web applications asynchronous requests to
                 remote services using callbacks or futures are
                 omnipresent. The continuation of such a non-blocking
                 task is represented as a callback function that will
                 later be called with the result of the request. This
                 style of programming where the remainder of a
                 computation is captured in a continuation function is
                 called continuation-passing style (CPS). This style of
                 programming can quickly lead to a phenomenon called
                 ``callback hell'', which has a negative impact on the
                 maintainability of applications that employ this style.
                 Several alternatives to callbacks are therefore gaining
                 traction within the web domain. For example, there are
                 a number of frameworks that rely on automatically
                 transforming sequential style code into the
                 continuation-passing style. However, these frameworks
                 often employ a conservative approach in which each
                 function call is transformed into CPS. This
                 conservative approach can sequentialise requests that
                 could otherwise be run in parallel. So-called delimited
                 continuations can remedy, but require special marks
                 that have to be manually inserted in the code for
                 marking the beginning and end of the continuation. In
                 this paper we propose an alternative strategy in which
                 we apply a delimited CPS transformation that operates
                 on a Program Dependence Graph instead to find the
                 limits of each continuation.We implement this strategy
                 in JavaScript and demonstrate its applicability to
                 various web programming scenarios.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "GPCE '16 conference proceedings.",
}

@Article{Piedrahita-Quintero:2017:JGA,
  author =       "Pablo Piedrahita-Quintero and Carlos Trujillo and
                 Jorge Garcia-Sucerquia",
  title =        "{JDiffraction}: a {GPGPU}-accelerated {JAVA} library
                 for numerical propagation of scalar wave fields",
  journal =      j-COMP-PHYS-COMM,
  volume =       "214",
  number =       "??",
  pages =        "128--139",
  month =        may,
  year =         "2017",
  CODEN =        "CPHCBZ",
  ISSN =         "0010-4655 (print), 1879-2944 (electronic)",
  ISSN-L =       "0010-4655",
  bibdate =      "Fri Mar 3 06:05:58 MST 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/compphyscomm2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0010465516303952",
  acknowledgement = ack-nhfb,
  fjournal =     "Computer Physics Communications",
  journal-URL =  "http://www.sciencedirect.com/science/journal/00104655",
}

@Article{Pizlo:2017:JVM,
  author =       "Filip Pizlo",
  title =        "The {JavaScriptCore} virtual machine (invited talk)",
  journal =      j-SIGPLAN,
  volume =       "52",
  number =       "11",
  pages =        "1--1",
  month =        nov,
  year =         "2017",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3170472.3148567",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Dec 1 18:56:13 MST 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "JavaScriptCore (JSC) is an open-source
                 high-performance implementation of JavaScript. JSC is
                 used in the WebKit open source browser engine as well
                 as a system framework on macOS and iOS. This talk will
                 give a broad high-level overview of JSC's
                 performance-oriented architecture, including specific
                 details about the object model, garbage collector,
                 optimizing compilers, type inference, and
                 deoptimization.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "DLS '17 conference proceedings.",
}

@Article{Powers:2017:BBG,
  author =       "Bobby Powers and John Vilk and Emery D. Berger",
  title =        "{Browsix}: Bridging the Gap Between {Unix} and the
                 Browser",
  journal =      j-COMP-ARCH-NEWS,
  volume =       "45",
  number =       "1",
  pages =        "253--266",
  month =        mar,
  year =         "2017",
  CODEN =        "CANED2",
  DOI =          "https://doi.org/10.1145/3093337.3037727",
  ISSN =         "0163-5964 (print), 1943-5851 (electronic)",
  ISSN-L =       "0163-5964",
  bibdate =      "Mon Jun 5 18:01:58 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigarch.bib;
                 https://www.math.utah.edu/pub/tex/bib/unix.bib",
  abstract =     "Applications written to run on conventional operating
                 systems typically depend on OS abstractions like
                 processes, pipes, signals, sockets, and a shared file
                 system. Porting these applications to the web currently
                 requires extensive rewriting or hosting significant
                 portions of code server-side because browsers present a
                 nontraditional runtime environment that lacks OS
                 functionality. This paper presents Browsix, a framework
                 that bridges the considerable gap between conventional
                 operating systems and the browser, enabling unmodified
                 programs expecting a Unix-like environment to run
                 directly in the browser. Browsix comprises two core
                 parts: (1) a JavaScript-only system that makes core
                 Unix features (including pipes, concurrent processes,
                 signals, sockets, and a shared file system) available
                 to web applications; and (2) extended JavaScript
                 runtimes for C, C++, Go, and Node.js that support
                 running programs written in these languages as
                 processes in the browser. Browsix supports running a
                 POSIX shell, making it straightforward to connect
                 applications together via pipes. We illustrate
                 Browsix's capabilities via case studies that
                 demonstrate how it eases porting legacy applications to
                 the browser and enables new functionality. We
                 demonstrate a Browsix-enabled LaTeX editor that
                 operates by executing unmodified versions of pdfLaTeX
                 and BibTeX. This browser-only LaTeX editor can render
                 documents in seconds, making it fast enough to be
                 practical. We further demonstrate how Browsix lets us
                 port a client-server application to run entirely in the
                 browser for disconnected operation. Creating these
                 applications required less than 50 lines of glue code
                 and no code modifications, demonstrating how easily
                 Browsix can be used to build sophisticated web
                 applications from existing parts without
                 modification.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGARCH Computer Architecture News",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J89",
  remark =       "ASPLOS'17 conference proceedings",
}

@Article{Qiu:2017:USR,
  author =       "Dong Qiu and Bixin Li and Earl T. Barr and Zhendong
                 Su",
  title =        "Understanding the syntactic rule usage in {Java}",
  journal =      j-J-SYST-SOFTW,
  volume =       "123",
  number =       "??",
  pages =        "160--172",
  month =        jan,
  year =         "2017",
  CODEN =        "JSSODM",
  ISSN =         "0164-1212 (print), 1873-1228 (electronic)",
  ISSN-L =       "0164-1212",
  bibdate =      "Thu Dec 8 12:35:58 MST 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/jsystsoftw.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0164121216302126",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Systems and Software",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01641212/",
}

@Article{Ramamohanarao:2017:SSM,
  author =       "Kotagiri Ramamohanarao and Hairuo Xie and Lars Kulik
                 and Shanika Karunasekera and Egemen Tanin and Rui Zhang
                 and Eman Bin Khunayn",
  title =        "{SMARTS}: Scalable Microscopic Adaptive Road Traffic
                 Simulator",
  journal =      j-TIST,
  volume =       "8",
  number =       "2",
  pages =        "26:1--26:??",
  month =        jan,
  year =         "2017",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/2898363",
  ISSN =         "2157-6904 (print), 2157-6912 (electronic)",
  ISSN-L =       "2157-6904",
  bibdate =      "Mon Apr 3 11:19:57 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/tist.bib",
  abstract =     "Microscopic traffic simulators are important tools for
                 studying transportation systems as they describe the
                 evolution of traffic to the highest level of detail. A
                 major challenge to microscopic simulators is the slow
                 simulation speed due to the complexity of traffic
                 models. We have developed the Scalable Microscopic
                 Adaptive Road Traffic Simulator (SMARTS), a distributed
                 microscopic traffic simulator that can utilize multiple
                 independent processes in parallel. SMARTS can perform
                 fast large-scale simulations. For example, when
                 simulating 1 million vehicles in an area the size of
                 Melbourne, the system runs 1.14 times faster than real
                 time with 30 computing nodes and 0.2s simulation
                 timestep. SMARTS supports various driver models and
                 traffic rules, such as the car-following model and
                 lane-changing model, which can be driver dependent. It
                 can simulate multiple vehicle types, including bus and
                 tram. The simulator is equipped with a wide range of
                 features that help to customize, calibrate, and monitor
                 simulations. Simulations are accurate and confirm with
                 real traffic behaviours. For example, it achieves
                 79.1\% accuracy in predicting traffic on a 10km freeway
                 90 minutes into the future. The simulator can be used
                 for predictive traffic advisories as well as traffic
                 management decisions as simulations complete well ahead
                 of real time. SMARTS can be easily deployed to
                 different operating systems as it is developed with the
                 standard Java libraries.",
  acknowledgement = ack-nhfb,
  articleno =    "26",
  fjournal =     "ACM Transactions on Intelligent Systems and Technology
                 (TIST)",
  journal-URL =  "http://portal.acm.org/citation.cfm?id=J1318",
}

@Article{Rathee:2017:ROO,
  author =       "Amit Rathee and Jitender Kumar Chhabra",
  title =        "Restructuring of Object-Oriented Software Through
                 Cohesion Improvement Using Frequent Usage Patterns",
  journal =      j-SIGSOFT,
  volume =       "42",
  number =       "3",
  pages =        "1--8",
  month =        jul,
  year =         "2017",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/3127360.3127370",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:16:47 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  abstract =     "Due to wide adoption of object-oriented programming in
                 software development, there is always a requirement to
                 produce well-designed software systems, so that the
                 overall software maintenance cost is reduced and
                 reusability of the component is increased. But, due to
                 prolonged maintenance activities, the internal
                 structure of software system deteriorates. In this
                 situation, restructuring is a widely used solution to
                 improve the overall internal structure of the system
                 without changing its external behavior. As, it is known
                 that, one technique to perform restructuring is to use
                 refactoring on the existing source code to alter its
                 internal structure without modifying its external
                 functionality. However, the refactoring solely depends
                 on our ability to identify various code smells present
                 in the system. Refactoring aims at improving cohesion
                 and reducing coupling in the software system. So, in
                 this paper, a restructuring approach based on
                 refactoring is proposed through improvement in
                 cohesion. This paper focuses on improving the cohesion
                 of different classes of object-oriented software using
                 a newly proposed similarity metric based on Frequent
                 Usage Patterns (FUP). The proposed similarity metric
                 measure the relatedness among member functions of the
                 classes. The metric makes use of FUPs used by member
                 functions. The FUP consists of unordered sequences of
                 member variables accessed by member function in
                 performing its task. The usage pattern includes both
                 direct and indirect usages based on sub-function calls
                 within a member function. Based on the values of the
                 similarity metric, we performed hierarchical
                 agglomerative clustering using complete linkage
                 strategy to cluster member functions. Finally, based on
                 the clusters obtained, the source code of the software
                 is refactored using proposed refactoring algorithm. The
                 applicability of our proposed approach is tested using
                 two java projects related to different domains of real
                 life. The result obtained encourages the applicability
                 of proposed approach in the restructuring of a software
                 system.patterns, refactoring, hierarchical clustering,
                 maintainability. usage patterns, refactoring,
                 hierarchical clustering, maintainability.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Rosa:2017:APV,
  author =       "Andrea Ros{\`a} and Lydia Y. Chen and Walter Binder",
  title =        "Actor profiling in virtual execution environments",
  journal =      j-SIGPLAN,
  volume =       "52",
  number =       "3",
  pages =        "36--46",
  month =        mar,
  year =         "2017",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3093335.2993241",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:15 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Nowadays, many virtual execution environments benefit
                 from concurrency offered by the actor model.
                 Unfortunately, while actors are used in many
                 applications, existing profiling tools are not much
                 effective in analyzing the performance of applications
                 using actors. In this paper, we present a new
                 instrumentation-based technique to profile actors in
                 virtual execution environments. Our technique adopts
                 platform-independent profiling metrics that minimize
                 the perturbations induced by the instrumentation logic
                 and allow comparing profiling results across different
                 platforms. In particular, our technique measures the
                 initialization cost, the amount of executed
                 computations, and the messages sent and received by
                 each actor. We implement our technique within a
                 profiling tool for Akka actors on the Java platform.
                 Evaluation results show that our profiling technique
                 helps performance analysis of actor utilization and
                 communication between actors in large-scale computing
                 frameworks.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "GPCE '16 conference proceedings.",
}

@Article{Rosa:2017:ARC,
  author =       "Andrea Ros{\`a} and Eduardo Rosales and Walter
                 Binder",
  title =        "Accurate reification of complete supertype information
                 for dynamic analysis on the {JVM}",
  journal =      j-SIGPLAN,
  volume =       "52",
  number =       "12",
  pages =        "104--116",
  month =        dec,
  year =         "2017",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3170492.3136061",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Dec 1 18:56:14 MST 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Reflective supertype information (RSI) is useful for
                 many instrumentation-based dynamic analyses on the Java
                 Virtual Machine (JVM). On the one hand, while such
                 information can be obtained when performing the
                 instrumentation within the same JVM process executing
                 the instrumented program, in-process instrumentation
                 severely limits the code coverage of the analysis. On
                 the other hand, performing the instrumentation in a
                 separate process can achieve full code coverage, but
                 complete RSI is generally not available, often
                 requiring expensive runtime checks in the instrumented
                 program. Providing accurate and complete RSI in the
                 instrumentation process is challenging because of
                 dynamic class loading and classloader namespaces. In
                 this paper, we present a novel technique to accurately
                 reify complete RSI in a separate instrumentation
                 process. We implement our technique in the dynamic
                 analysis framework DiSL and evaluate it on a task
                 profiler, achieving speedups of up to 45\% for an
                 analysis with full code coverage.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "GPCE '17 conference proceedings.",
}

@Article{Rudafshani:2017:LDD,
  author =       "Masoomeh Rudafshani and Paul A. S. Ward",
  title =        "{LeakSpot}: detection and diagnosis of memory leaks in
                 {JavaScript} applications",
  journal =      j-SPE,
  volume =       "47",
  number =       "1",
  pages =        "97--123",
  month =        jan,
  year =         "2017",
  CODEN =        "SPEXBL",
  DOI =          "https://doi.org/10.1002/spe.2406",
  ISSN =         "0038-0644 (print), 1097-024X (electronic)",
  ISSN-L =       "0038-0644",
  bibdate =      "Sat Feb 18 10:00:11 MST 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/spe.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Software --- Practice and Experience",
  journal-URL =  "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)1097-024X",
}

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

@Article{Schoeberl:2017:SCJ,
  author =       "Martin Schoeberl and Andreas Engelbredt Dalsgaard and
                 Ren{\'e} Rydhof Hansen and Stephan E. Korsholm and
                 Anders P. Ravn and Juan Ricardo Rios Rivas and
                 T{\'o}rur Biskopst{\o} Str{\o}m and Hans S{\o}ndergaard
                 and Andy Wellings and Shuai Zhao",
  title =        "Safety-critical {Java} for embedded systems",
  journal =      j-CCPE,
  volume =       "29",
  number =       "22",
  pages =        "??--??",
  day =          "25",
  month =        nov,
  year =         "2017",
  CODEN =        "CCPEBO",
  DOI =          "https://doi.org/10.1002/cpe.3963",
  ISSN =         "1532-0626 (print), 1532-0634 (electronic)",
  ISSN-L =       "1532-0626",
  bibdate =      "Sat Dec 30 09:11:59 MST 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Concurrency and Computation: Practice and Experience",
  journal-URL =  "http://www.interscience.wiley.com/jpages/1532-0626",
}

@Article{Sharma:2017:VCS,
  author =       "Vaibhav Sharma and Michael W. Whalen and Stephen
                 McCamant and Willem Visser",
  title =        "{Veritesting} Challenges in Symbolic Execution of
                 {Java}",
  journal =      j-SIGSOFT,
  volume =       "42",
  number =       "4",
  pages =        "1--5",
  month =        oct,
  year =         "2017",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/3149485.3149491",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:16:48 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  abstract =     "Scaling symbolic execution to industrial-sized
                 programs is an important open research problem.
                 Veritesting is a promising technique that improves
                 scalability by combining the advantages of static
                 symbolic execution with those of dynamic symbolic
                 execution. The goal of veritesting is to reduce the
                 number of paths to explore in symbolic execution by
                 creating formulas describing regions of code using
                 disjunctive formulas. In previous work, veritesting was
                 applied to binary-level symbolic execution. Integrating
                 veritesting with Java bytecode presents unique
                 challenges: notably, incorporating non-local control
                 jumps caused by runtime polymorphism, exceptions,
                 native calls, and dynamic class loading. If these
                 language features are not accounted for, we hypothesize
                 that the static code regions described by veritesting
                 are often small and may not lead to substantial
                 reduction in paths. We examine this hypothesis by
                 running a Soot-based static analysis on six large
                 open-source projects used in the Defects4J collection.
                 We find that while veritesting can be applied in
                 thousands of regions, allowing static symbolic
                 execution involving non-local control jumps amplifies
                 the performance improvement obtained from veritesting.
                 We hope to use these insights to support efficient
                 veritesting in Symbolic PathFinder in the near future.
                 Toward this end, we brie y address some engineering
                 challenges to add veritesting into SPF.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Siek:2017:CPT,
  author =       "Jeremy Siek",
  title =        "Challenges and progress toward efficient gradual
                 typing (invited talk)",
  journal =      j-SIGPLAN,
  volume =       "52",
  number =       "11",
  pages =        "2--2",
  month =        nov,
  year =         "2017",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3170472.3148570",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Dec 1 18:56:13 MST 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Mixing static and dynamic type checking in the same
                 language is catching on, with the TypeScript and Flow
                 variants of JavaScript, the MyPy and Reticulated
                 variants of Python, the Strongtalk and Gradualtalk
                 variants of Smalltalk, as well as Typed Racket, Typed
                 Clojure, and Perl 6. The gradual typing approach to
                 such mixing seeks to protect the statically typed code
                 from the dynamically typed code, allowing compilers to
                 leverage type information when optimizing the static
                 code. Unfortunately, ensuring soundness requires
                 runtime checking at the boundaries of typed and untyped
                 code, and the cost of this checking can drown out the
                 performance benefits of optimization. For example, in
                 Typed Racket, some partially typed programs are 1000X
                 slower than the untyped or fully typed version of the
                 same program. But all is not lost! In this talk I
                 present the results of ongoing research to tame the
                 runtime overheads of gradual typing in the context of a
                 prototype compiler, named Grift, that we are developing
                 at Indiana University.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "DLS '17 conference proceedings.",
}

@Article{Silva:2017:ICL,
  author =       "Leonardo Humberto Silva and Marco Tulio Valente and
                 Alexandre Bergel and Nicolas Anquetil and Anne Etien",
  title =        "Identifying Classes in Legacy {JavaScript} Code",
  journal =      j-J-SOFTW-EVOL-PROC,
  volume =       "29",
  number =       "8",
  pages =        "??--??",
  month =        aug,
  year =         "2017",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1002/smr.1864",
  ISSN =         "2047-7473 (print), 2047-7481 (electronic)",
  ISSN-L =       "2047-7473",
  bibdate =      "Wed Jan 31 13:48:49 MST 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/jsoftwevolproc.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Software: Evolution and Process",
  journal-URL =  "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)2047-7481",
}

@Article{Sondergaard:2017:CTD,
  author =       "Hans S{\o}ndergaard and Stephan E. Korsholm and Anders
                 P. Ravn",
  title =        "Conformance test development with the {Java} modeling
                 language",
  journal =      j-CCPE,
  volume =       "29",
  number =       "22",
  pages =        "??--??",
  day =          "25",
  month =        nov,
  year =         "2017",
  CODEN =        "CCPEBO",
  DOI =          "https://doi.org/10.1002/cpe.4071",
  ISSN =         "1532-0626 (print), 1532-0634 (electronic)",
  ISSN-L =       "1532-0626",
  bibdate =      "Sat Dec 30 09:11:59 MST 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Concurrency and Computation: Practice and Experience",
  journal-URL =  "http://www.interscience.wiley.com/jpages/1532-0626",
}

@Article{Srikanth:2017:CVU,
  author =       "Akhilesh Srikanth and Burak Sahin and William R.
                 Harris",
  title =        "Complexity verification using guided theorem
                 enumeration",
  journal =      j-SIGPLAN,
  volume =       "52",
  number =       "1",
  pages =        "639--652",
  month =        jan,
  year =         "2017",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3093333.3009864",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:14 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Determining if a given program satisfies a given bound
                 on the amount of resources that it may use is a
                 fundamental problem with critical practical
                 applications. Conventional automatic verifiers for
                 safety properties cannot be applied to address this
                 problem directly because such verifiers target
                 properties expressed in decidable theories; however,
                 many practical bounds are expressed in nonlinear
                 theories, which are undecidable. In this work, we
                 introduce an automatic verification algorithm, CAMPY,
                 that determines if a given program P satisfies a given
                 resource bound B, which may be expressed using
                 polynomial, exponential, and logarithmic terms. The key
                 technical contribution behind our verifier is an
                 interpolating theorem prover for non-linear theories
                 that lazily learns a sufficiently accurate
                 approximation of non-linear theories by selectively
                 grounding theorems of the nonlinear theory that are
                 relevant to proving that P satisfies B. To evaluate
                 CAMPY, we implemented it to target Java Virtual Machine
                 bytecode. We applied CAMPY to verify that over 20
                 solutions submitted for programming problems hosted on
                 popular online coding platforms satisfy or do not
                 satisfy expected complexity bounds.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "POPL '17 conference proceedings.",
}

@Article{Steindorfer:2017:TSP,
  author =       "Michael J. Steindorfer and Jurgen J. Vinju",
  title =        "Towards a software product line of trie-based
                 collections",
  journal =      j-SIGPLAN,
  volume =       "52",
  number =       "3",
  pages =        "168--172",
  month =        mar,
  year =         "2017",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3093335.2993251",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:15 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Collection data structures in standard libraries of
                 programming languages are designed to excel for the
                 average case by carefully balancing memory footprint
                 and runtime performance. These implicit design
                 decisions and hard-coded trade-offs do constrain users
                 from using an optimal variant for a given problem.
                 Although a wide range of specialized collections is
                 available for the Java Virtual Machine (JVM), they
                 introduce yet another dependency and complicate user
                 adoption by requiring specific Application Program
                 Interfaces (APIs) incompatible with the standard
                 library. A product line for collection data structures
                 would relieve library designers from optimizing for the
                 general case. Furthermore, a product line allows
                 evolving the potentially large code base of a
                 collection family efficiently. The challenge is to find
                 a small core framework for collection data structures
                 which covers all variations without exhaustively
                 listing them, while supporting good performance at the
                 same time. We claim that the concept of Array Mapped
                 Tries (AMTs) embodies a high degree of commonality in
                 the sub-domain of immutable collection data structures.
                 AMTs are flexible enough to cover most of the
                 variability, while minimizing code bloat in the
                 generator and the generated code. We implemented a Data
                 Structure Code Generator (DSCG) that emits immutable
                 collections based on an AMT skeleton foundation. The
                 generated data structures outperform competitive
                 hand-optimized implementations, and the generator still
                 allows for customization towards specific workloads.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "GPCE '16 conference proceedings.",
}

@Article{Stilkerich:2017:PGU,
  author =       "Isabella Stilkerich and Clemens Lang and Christoph
                 Erhardt and Christian Bay and Michael Stilkerich",
  title =        "The Perfect Getaway: Using Escape Analysis in Embedded
                 Real-Time Systems",
  journal =      j-TECS,
  volume =       "16",
  number =       "4",
  pages =        "99:1--99:30",
  month =        aug,
  year =         "2017",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/3035542",
  ISSN =         "1539-9087 (print), 1558-3465 (electronic)",
  ISSN-L =       "1539-9087",
  bibdate =      "Mon Aug 14 18:53:33 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/tecs.bib",
  abstract =     "The use of a managed, type-safe language such as Java
                 in real-time and embedded systems offers productivity
                 and, in particular, safety and dependability benefits
                 at a reasonable cost. It has been shown for commodity
                 systems that Escape Analysis (EA) enables a set of
                 useful optimizations, and benefits from the properties
                 of a type-safe language. In this article, we explore
                 the application of escape analysis in KESO [Stilkerich
                 et al. 2012], a Java ahead-of-time compiler targeting
                 embedded real-time systems. We present specific
                 applications of EA for embedded programs that go beyond
                 the widely known stack-allocation and synchronization
                 optimizations such as extended remote-procedure-call
                 (RPC) support for software-isolated applications,
                 automated inference of immutable data, or improved
                 upper space and time bounds for worst-case
                 estimations.",
  acknowledgement = ack-nhfb,
  articleno =    "99",
  fjournal =     "ACM Transactions on Embedded Computing Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J840",
}

@Article{Strom:2017:HLR,
  author =       "T{\'o}rur Biskopst{\o} Str{\o}m and Wolfgang Puffitsch
                 and Martin Schoeberl",
  title =        "Hardware locks for a real-time {Java} chip
                 multiprocessor",
  journal =      j-CCPE,
  volume =       "29",
  number =       "6",
  pages =        "??--??",
  day =          "25",
  month =        mar,
  year =         "2017",
  CODEN =        "CCPEBO",
  DOI =          "https://doi.org/10.1002/cpe.3950",
  ISSN =         "1532-0626 (print), 1532-0634 (electronic)",
  ISSN-L =       "1532-0626",
  bibdate =      "Fri Mar 31 19:12:51 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Concurrency and Computation: Practice and Experience",
  journal-URL =  "http://www.interscience.wiley.com/jpages/1532-0626",
}

@Article{Subercaze:2017:UPT,
  author =       "Julien Subercaze and Christophe Gravier and Syed
                 Gillani and Abderrahmen Kammoun and Fr{\'e}d{\'e}rique
                 Laforest",
  title =        "{Upsortable}: programming top-$k$ queries over data
                 streams",
  journal =      j-PROC-VLDB-ENDOWMENT,
  volume =       "10",
  number =       "12",
  pages =        "1873--1876",
  month =        aug,
  year =         "2017",
  CODEN =        "????",
  DOI =          "https://doi.org/10.14778/3137765.3137797",
  ISSN =         "2150-8097",
  bibdate =      "Tue Oct 10 17:16:19 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/vldbe.bib",
  abstract =     "Top-$k$ queries over data streams is a well studied
                 problem. There exists numerous systems allowing to
                 process continuous queries over sliding windows. At the
                 opposite, non-append only streams call for ad-hoc
                 solutions, e.g. tailor-made solutions implemented in a
                 mainstream programming language. In the meantime, the
                 Stream API and lambda expressions have been added in
                 Java 8, thus gaining powerful operations for data
                 stream processing. However, the Java Collections
                 Framework does not provide data structures to safely
                 and conveniently support sorted collections of evolving
                 data. In this paper, we demonstrate Upsortable, an
                 annotation-based approach that allows to use existing
                 sorted collections from the standard Java API for
                 dynamic data management. Our approach relies on a
                 combination of pre-compilation abstract syntax tree
                 modifications and runtime analysis of bytecode.
                 Upsortable offers the developer a safe and
                 time-efficient solution for developing top-$k$ queries
                 on data streams while keeping a full compatibility with
                 standard Java.",
  acknowledgement = ack-nhfb,
  fjournal =     "Proceedings of the VLDB Endowment",
  journal-URL =  "http://portal.acm.org/citation.cfm?id=J1174",
}

@Article{Sun:2017:AJP,
  author =       "Kwangwon Sun and Sukyoung Ryu",
  title =        "Analysis of {JavaScript} Programs: Challenges and
                 Research Trends",
  journal =      j-COMP-SURV,
  volume =       "50",
  number =       "4",
  pages =        "59:1--59:??",
  month =        nov,
  year =         "2017",
  CODEN =        "CMSVAN",
  DOI =          "https://doi.org/10.1145/3106741",
  ISSN =         "0360-0300 (print), 1557-7341 (electronic)",
  ISSN-L =       "0360-0300",
  bibdate =      "Sat Jan 20 09:25:00 MST 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/compsurv.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "JavaScript has been a de facto standard language for
                 client-side web programs, and now it is expanding its
                 territory to general purpose programs. In this article,
                 we classify the client-side JavaScript research for the
                 last decade or so into six topics: static analysis,
                 dynamic analysis, formalization and reasoning, type
                 safety and JIT optimization, security for web
                 applications, and empirical studies. Because the
                 majority of the research has focused on static and
                 dynamic analyses of JavaScript, we evaluate research
                 trends in the analysis of JavaScript first and then the
                 other topics. Finally, we discuss possible future
                 research directions with open challenges.",
  acknowledgement = ack-nhfb,
  articleno =    "59",
  fjournal =     "ACM Computing Surveys",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J204",
}

@Article{Tan:2017:EPP,
  author =       "Tian Tan and Yue Li and Jingling Xue",
  title =        "Efficient and precise points-to analysis: modeling the
                 heap by merging equivalent automata",
  journal =      j-SIGPLAN,
  volume =       "52",
  number =       "6",
  pages =        "278--291",
  month =        jun,
  year =         "2017",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3140587.3062360",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:17 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Mainstream points-to analysis techniques for
                 object-oriented languages rely predominantly on the
                 allocation-site abstraction to model heap objects. We
                 present MAHJONG, a novel heap abstraction that is
                 specifically developed to address the needs of an
                 important class of type-dependent clients, such as call
                 graph construction, devirtualization and may-fail
                 casting. By merging equivalent automata representing
                 type-consistent objects that are created by the
                 allocation-site abstraction, MAHJONG enables an
                 allocation-site-based points-to analysis to run
                 significantly faster while achieving nearly the same
                 precision for type-dependent clients. MAHJONG is simple
                 conceptually, efficient, and drops easily on any
                 allocation-site-based points-to analysis. We
                 demonstrate its effectiveness by discussing some
                 insights on why it is a better alternative of the
                 allocation-site abstraction for type-dependent clients
                 and evaluating it extensively on 12 large real-world
                 Java programs with five context-sensitive points-to
                 analyses and three widely used type-dependent clients.
                 MAHJONG is expected to provide significant benefits for
                 many program analyses where call graphs are required.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "PLDI '17 conference proceedings.",
}

@Article{Thiessen:2017:CTP,
  author =       "Rei Thiessen and Ondrej Lhot{\'a}k",
  title =        "Context transformations for pointer analysis",
  journal =      j-SIGPLAN,
  volume =       "52",
  number =       "6",
  pages =        "263--277",
  month =        jun,
  year =         "2017",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3140587.3062359",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:17 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Points-to analysis for Java benefits greatly from
                 context sensitivity. CFL-reachability and k -limited
                 context strings are two approaches to obtaining context
                 sensitivity with different advantages: CFL-reachability
                 allows local reasoning about data-value flow and thus
                 is suitable for demand-driven analyses, whereas k
                 -limited analyses allow object sensitivity which is a
                 superior calling context abstraction for
                 object-oriented languages. We combine the advantages of
                 both approaches to obtain a context-sensitive analysis
                 that is as precise as k -limited context strings, but
                 is more efficient to compute. Our key insight is based
                 on a novel abstraction of contexts adapted from
                 CFL-reachability that represents a relation between two
                 calling contexts as a composition of transformations
                 over contexts. We formulate pointer analysis in an
                 algebraic structure of context transformations, which
                 is a set of functions over calling contexts closed
                 under function composition. We show that the context
                 representation of context-string-based analyses is an
                 explicit enumeration of all input and output values of
                 context transformations. CFL-reachability-based pointer
                 analysis is formulated to use call-strings as contexts,
                 but the context transformations concept can be applied
                 to any context abstraction used in k -limited analyses,
                 including object- and type-sensitive analysis. The
                 result is a more efficient algorithm for computing
                 context-sensitive results for a wide variety of context
                 configurations.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "PLDI '17 conference proceedings.",
}

@InProceedings{Tomescu:2017:CEN,
  author =       "A. Tomescu and S. Devadas",
  booktitle =    "2017 IEEE Symposium on Security and Privacy (SP)",
  title =        "{Catena}: Efficient Non-equivocation via {Bitcoin}",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "393--409",
  month =        may,
  year =         "2017",
  DOI =          "https://doi.org/10.1109/SP.2017.19",
  ISSN =         "",
  bibdate =      "Thu Nov 30 15:24:52 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/bitcoin.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  keywords =     "adversarial server; Bandwidth; bitcoinj library;
                 Catena; CONIKS; efficiently-verifiable {Bitcoin}
                 witnessing scheme; file servers; Java; key transparency
                 scheme; nonequivocation; OP_RETURN transaction chain;
                 Prototypes; Public key; public key cryptography;
                 public-key directory; Servers; Software; {Bitcoin};
                 {Bitcoin} blockchain",
}

@Article{Tommasel:2017:SJL,
  author =       "Antonela Tommasel and Daniela Godoy and Alejandro
                 Zunino",
  title =        "{SMArtOp}: a {Java} library for distributing
                 high-dimensional sparse-matrix arithmetic operations",
  journal =      j-SCI-COMPUT-PROGRAM,
  volume =       "150",
  number =       "??",
  pages =        "26--30",
  day =          "15",
  month =        dec,
  year =         "2017",
  CODEN =        "SCPGD4",
  ISSN =         "0167-6423 (print), 1872-7964 (electronic)",
  ISSN-L =       "0167-6423",
  bibdate =      "Mon Oct 30 08:29:26 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/scicomputprogram.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0167642317301260",
  acknowledgement = ack-nhfb,
  fjournal =     "Science of Computer Programming",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01676423",
}

@Article{Varier:2017:TNJ,
  author =       "K. Muraleedhara Varier and V. Sankar and M. P.
                 Gangadathan",
  title =        "{TrackEtching} --- A {Java} based code for etched
                 track profile calculations in {SSNTDs}",
  journal =      j-COMP-PHYS-COMM,
  volume =       "218",
  number =       "??",
  pages =        "43--47",
  month =        sep,
  year =         "2017",
  CODEN =        "CPHCBZ",
  ISSN =         "0010-4655 (print), 1879-2944 (electronic)",
  ISSN-L =       "0010-4655",
  bibdate =      "Wed Jul 26 06:22:13 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/compphyscomm2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0010465517301273",
  acknowledgement = ack-nhfb,
  fjournal =     "Computer Physics Communications",
  journal-URL =  "http://www.sciencedirect.com/science/journal/00104655",
}

@Article{Viotti:2017:HRH,
  author =       "Paolo Viotti and Dan Dobre and Marko Vukoli{\'c}",
  title =        "{Hybris}: Robust Hybrid Cloud Storage",
  journal =      j-TOS,
  volume =       "13",
  number =       "3",
  pages =        "27:1--27:??",
  month =        oct,
  year =         "2017",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/3119896",
  ISSN =         "1553-3077 (print), 1553-3093 (electronic)",
  ISSN-L =       "1553-3077",
  bibdate =      "Mon Oct 30 08:04:10 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/tos.bib",
  abstract =     "Besides well-known benefits, commodity cloud storage
                 also raises concerns that include security,
                 reliability, and consistency. We present Hybris
                 key-value store, the first robust hybrid cloud storage
                 system, aiming at addressing these concerns leveraging
                 both private and public cloud resources. Hybris
                 robustly replicates metadata on trusted private
                 premises (private cloud), separately from data, which
                 are dispersed (using replication or erasure coding)
                 across multiple untrusted public clouds. Hybris
                 maintains metadata stored on private premises at the
                 order of few dozens of bytes per key, avoiding the
                 scalability bottleneck at the private cloud. In turn,
                 the hybrid design allows Hybris to efficiently and
                 robustly tolerate cloud outages but also potential
                 malice in clouds without overhead. Namely, to tolerate
                 up to $f$ malicious clouds, in the common case of the
                 Hybris variant with data replication, writes replicate
                 data across $ f + 1$ clouds, whereas reads involve a
                 single cloud. In the worst case, only up to $f$
                 additional clouds are used. This is considerably better
                 than earlier multi-cloud storage systems that required
                 costly $ 3 f + 1$ clouds to mask $f$ potentially
                 malicious clouds. Finally, Hybris leverages strong
                 metadata consistency to guarantee to Hybris
                 applications strong data consistency without any
                 modifications to the eventually consistent public
                 clouds. We implemented Hybris in Java and evaluated it
                 using a series of micro and macro-benchmarks. Our
                 results show that Hybris significantly outperforms
                 comparable multi-cloud storage systems and approaches
                 the performance of bare-bone commodity public cloud
                 storage.",
  acknowledgement = ack-nhfb,
  articleno =    "27",
  fjournal =     "ACM Transactions on Storage",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J960",
}

@Article{Wade:2017:AVJ,
  author =       "April W. Wade and Prasad A. Kulkarni and Michael R.
                 Jantz",
  title =        "{AOT} vs. {JIT}: impact of profile data on code
                 quality",
  journal =      j-SIGPLAN,
  volume =       "52",
  number =       "4",
  pages =        "1--10",
  month =        may,
  year =         "2017",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3140582.3081037",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:15 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Just-in-time (JIT) compilation during program
                 execution and ahead-of-time (AOT) compilation during
                 software installation are alternate techniques used by
                 managed language virtual machines (VM) to generate
                 optimized native code while simultaneously achieving
                 binary code portability and high execution performance.
                 Profile data collected by JIT compilers at run-time can
                 enable profile-guided optimizations (PGO) to customize
                 the generated native code to different program inputs.
                 AOT compilation removes the speed and energy overhead
                 of online profile collection and dynamic compilation,
                 but may not be able to achieve the quality and
                 performance of customized native code. The goal of this
                 work is to investigate and quantify the implications of
                 the AOT compilation model on the quality of the
                 generated native code for current VMs. First, we
                 quantify the quality of native code generated by the
                 two compilation models for a state-of-the-art (HotSpot)
                 Java VM. Second, we determine how the amount of profile
                 data collected affects the quality of generated code.
                 Third, we develop a mechanism to determine the accuracy
                 or similarity for different profile data for a given
                 program run, and investigate how the accuracy of
                 profile data affects its ability to effectively guide
                 PGOs. Finally, we categorize the profile data types in
                 our VM and explore the contribution of each such
                 category to performance.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "LCTES '17 conference proceedings.",
}

@Article{Wang:2017:CJ,
  author =       "Yanlin Wang and Haoyuan Zhang and Bruno C. d. S.
                 Oliveira and Marco Servetto",
  title =        "Classless {Java}",
  journal =      j-SIGPLAN,
  volume =       "52",
  number =       "3",
  pages =        "14--24",
  month =        mar,
  year =         "2017",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3093335.2993238",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:15 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "This paper presents an OO style without classes, which
                 we call interface-based object-oriented programming
                 (IB). IB is a natural extension of closely related
                 ideas such as traits. Abstract state operations provide
                 a new way to deal with state, which allows for
                 flexibility not available in class-based languages. In
                 IB state can be type-refined in subtypes. The
                 combination of a purely IB style and type-refinement
                 enables powerful idioms using multiple inheritance and
                 state. To introduce IB to programmers we created
                 Classless Java: an embedding of IB directly into Java.
                 Classless Java uses annotation processing for code
                 generation and relies on new features of Java 8 for
                 interfaces. The code generation techniques used in
                 Classless Java have interesting properties, including
                 guarantees that the generated code is type-safe and
                 good integration with IDEs. Usefulness of IB and
                 Classless Java is shown with examples and case
                 studies.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "GPCE '16 conference proceedings.",
}

@Article{Wang:2017:JRJ,
  author =       "Kaiyuan Wang and Sarfraz Khurshid and Milos Gligoric",
  title =        "{JPR}: Replaying {JPF} Traces Using Standard {JVM}",
  journal =      j-SIGSOFT,
  volume =       "42",
  number =       "4",
  pages =        "1--5",
  month =        oct,
  year =         "2017",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/3149485.3149494",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Aug 1 17:16:48 MDT 2018",
  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/sigsoft2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  abstract =     "Java PathFinder (JPF) is a backtrackable Java Virtual
                 Machine (JVM), which is implemented in Java and runs on
                 a standard JVM (e.g., Oracle HotSpot). Thus, a JPF
                 developer can use off-the-shelf Java debuggers (e.g.,
                 jdb) when debugging code that makes up JPF. JPF
                 explores all non-deterministic executions of a given
                 target program and monitors for property violations. To
                 facilitate debugging of the target program, JPF can
                 capture and replay the execution trace that leads to a
                 property violation. While the deterministic replay is
                 invaluable, the replay with JPF does not allow the
                 developer to attach an off-the-shelf Java debugger to
                 the target program (e.g., step through the application
                 code, set breakpoints, etc.). We present a technique,
                 dubbed JPR, to improve the debugging experience of the
                 JPF captured traces by migrating the JPF traces to a
                 new format that can be executed using the standard JVM.
                 JPR annotates each JPF trace, during the capture phase,
                 with extra data (e.g., instruction index, instruction
                 count, etc.); the annotated trace is then used to
                 instrument Java bytecode to enforce the same execution
                 trace on a standard JVM. JPR is compatible with various
                 optimizations, e.g., state matching and partial-order
                 reduction. We evaluated JPR on all multithreaded Java
                 programs in the official JPF distribution. Our results
                 show that JPR successfully replayed all JPF traces on
                 the standard JVM with reasonable overhead during both
                 recording and replaying.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Wurthinger:2017:PPE,
  author =       "Thomas W{\"u}rthinger and Christian Wimmer and
                 Christian Humer and Andreas W{\"o}{\ss} and Lukas
                 Stadler and Chris Seaton and Gilles Duboscq and Doug
                 Simon and Matthias Grimmer",
  title =        "Practical partial evaluation for high-performance
                 dynamic language runtimes",
  journal =      j-SIGPLAN,
  volume =       "52",
  number =       "6",
  pages =        "662--676",
  month =        jun,
  year =         "2017",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3140587.3062381",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:17 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Most high-performance dynamic language virtual
                 machines duplicate language semantics in the
                 interpreter, compiler, and runtime system. This
                 violates the principle to not repeat yourself. In
                 contrast, we define languages solely by writing an
                 interpreter. The interpreter performs specializations,
                 e.g., augments the interpreted program with type
                 information and profiling information. Compiled code is
                 derived automatically using partial evaluation while
                 incorporating these specializations. This makes partial
                 evaluation practical in the context of dynamic
                 languages: It reduces the size of the compiled code
                 while still compiling all parts of an operation that
                 are relevant for a particular program. When a
                 speculation fails, execution transfers back to the
                 interpreter, the program re-specializes in the
                 interpreter, and later partial evaluation again
                 transforms the new state of the interpreter to compiled
                 code. We evaluate our approach by comparing our
                 implementations of JavaScript, Ruby, and R with
                 best-in-class specialized production implementations.
                 Our general-purpose compilation system is competitive
                 with production systems even when they have been
                 heavily optimized for the one language they support.
                 For our set of benchmarks, our speedup relative to the
                 V8 JavaScript VM is 0.83x, relative to JRuby is 3.8x,
                 and relative to GNU R is 5x.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "PLDI '17 conference proceedings.",
}

@Article{Xuan:2017:NAR,
  author =       "J. Xuan and M. Martinez and F. DeMarco and M.
                 Cl{\'e}ment and S. L. Marcote and T. Durieux and D. {Le
                 Berre} and M. Monperrus",
  title =        "{Nopol}: Automatic Repair of Conditional Statement
                 Bugs in {Java} Programs",
  journal =      j-IEEE-TRANS-SOFTW-ENG,
  volume =       "43",
  number =       "1",
  pages =        "34--55",
  month =        jan,
  year =         "2017",
  CODEN =        "IESEDJ",
  DOI =          "https://doi.org/10.1109/TSE.2016.2560811",
  ISSN =         "0098-5589 (print), 1939-3520 (electronic)",
  ISSN-L =       "0098-5589",
  bibdate =      "Thu Feb 1 19:49:24 MST 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ieeetranssoftweng2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=7463060",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE Transactions on Software Engineering",
  journal-URL =  "http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=32",
}

@Article{Yan:2017:AAA,
  author =       "Hua Yan and Yulei Sui and Shiping Chen and Jingling
                 Xue",
  title =        "{AutoFix}: an automated approach to memory leak fixing
                 on value-flow slices for {C} programs",
  journal =      j-SIGAPP,
  volume =       "16",
  number =       "4",
  pages =        "38--50",
  month =        jan,
  year =         "2017",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/3040575.3040579",
  ISSN =         "1559-6915 (print), 1931-0161 (electronic)",
  ISSN-L =       "1559-6915",
  bibdate =      "Thu Jan 23 10:25:02 MST 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigapp2010.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3040575.3040579",
  abstract =     "C is the most widely used programming language for
                 developing embedded software, operating systems, and
                 device drivers. Unlike programs written in managed
                 languages like Java, C programs rely on explicit memory
                 management, and are therefore prone to \ldots{}",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGAPP Applied Computing Review",
  journal-URL =  "https://dl.acm.org/loi/sigapp",
}

@Article{Yang:2017:EJV,
  author =       "Byung-Sun Yang and Jae-Yun Kim and Soo-Mook Moon",
  title =        "Exceptionization: a {Java} {VM} Optimization for
                 Non-{Java} Languages",
  journal =      j-TACO,
  volume =       "14",
  number =       "1",
  pages =        "5:1--5:??",
  month =        apr,
  year =         "2017",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/3046681",
  ISSN =         "1544-3566 (print), 1544-3973 (electronic)",
  ISSN-L =       "1544-3566",
  bibdate =      "Mon Jul 24 18:00:58 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/taco.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  abstract =     "Java virtual machine (JVM) has recently evolved into a
                 general-purpose language runtime environment to execute
                 popular programming languages such as JavaScript, Ruby,
                 Python, and Scala. These languages have complex
                 non-Java features, including dynamic typing and
                 first-class function, so additional language runtimes
                 (engines) are provided on top of the JVM to support
                 them with bytecode extensions. Although there are
                 high-performance JVMs with powerful just-in-time (JIT)
                 compilers, running these languages efficiently on the
                 JVM is still a challenge. This article introduces a
                 simple and novel technique for the JVM JIT compiler
                 called exceptionization to improve the performance of
                 JVM-based language runtimes. We observed that the JVM
                 executing some non-Java languages encounters at least 2
                 times more branch bytecodes than Java, most of which
                 are highly biased to take only one target.
                 Exceptionization treats such a highly biased branch as
                 some implicit exception-throwing instruction. This
                 allows the JVM JIT compiler to prune the infrequent
                 target of the branch from the frequent control flow,
                 thus compiling the frequent control flow more
                 aggressively with better optimization. If a pruned path
                 were taken, then it would run like a Java exception
                 handler, that is, a catch block. We also devised
                 de-exceptionization, a mechanism to cope with the case
                 when a pruned path is executed more often than
                 expected. Since exceptionization is a generic JVM
                 optimization, independent of any specific language
                 runtime, it would be generally applicable to other
                 language runtimes on the JVM. Our experimental result
                 shows that exceptionization accelerates the performance
                 of several non-Java languages. For example,
                 JavaScript-on-JVM runs faster by as much as 60\% and by
                 6\% on average, when experimented with the Octane
                 benchmark suite on Oracle's latest Nashorn JavaScript
                 engine and HotSpot 1.9 JVM. Furthermore, the
                 performance of Ruby-on-JVM shows an improvement by as
                 much as 60\% and by 6\% on average, while Python-on-JVM
                 improves by as much as 6\% and by 2\% on average. We
                 found that exceptionization is more effective to apply
                 to the branch bytecode of the language runtime itself
                 than the bytecode corresponding to the application code
                 or the bytecode of the Java class libraries. This
                 implies that the performance benefit of
                 exceptionization comes from better JIT compilation of
                 the language runtime of non-Java languages.",
  acknowledgement = ack-nhfb,
  articleno =    "5",
  fjournal =     "ACM Transactions on Architecture and Code Optimization
                 (TACO)",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J924",
}

@Article{Yessenov:2017:DAD,
  author =       "Kuat Yessenov and Ivan Kuraj and Armando
                 Solar-Lezama",
  title =        "{DemoMatch}: {API} discovery from demonstrations",
  journal =      j-SIGPLAN,
  volume =       "52",
  number =       "6",
  pages =        "64--78",
  month =        jun,
  year =         "2017",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3140587.3062386",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:17 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "We introduce DemoMatch, a tool for API discovery that
                 allows the user to discover how to implement
                 functionality using a software framework by
                 demonstrating the functionality in existing
                 applications built with the same framework. DemoMatch
                 matches the demonstrations against a database of
                 execution traces called Semeru and generates code
                 snippets explaining how to use the functionality. We
                 evaluated DemoMatch on several case studies involving
                 Java Swing and Eclipse RCP.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "PLDI '17 conference proceedings.",
}

@Article{Zacharopoulos:2017:EMM,
  author =       "Theologos Zacharopoulos and Pablo Inostroza and Tijs
                 van der Storm",
  title =        "Extensible modeling with managed data in {Java}",
  journal =      j-SIGPLAN,
  volume =       "52",
  number =       "3",
  pages =        "25--35",
  month =        mar,
  year =         "2017",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3093335.2993240",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Sat Sep 16 10:18:15 MDT 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Many model-driven development (MDD) tools employ
                 specialized frameworks and modeling languages, and
                 assume that the semantics of models is provided by some
                 form of code generation. As a result, programming
                 against models is cumbersome and does not integrate
                 well with ordinary programming languages and IDEs. In
                 this paper we present MD4J, a modeling approach for
                 embedding metamodels directly in Java, using plain
                 interfaces and annotations. The semantics is provided
                 by data managers that create and manipulate models.
                 This architecture enables two kinds of extensibility.
                 First, the data managers can be changed or extended to
                 obtain different base semantics of a model. This allows
                 a kind of aspect-oriented programming. Second, the
                 metamodels themselves can be extended with additional
                 fields and methods to modularly enrich a modeling
                 language. We illustrate our approach using the example
                 of state machines, discuss the implementation, and
                 evaluate it with two case-studies: the execution of UML
                 activity diagrams and an aspect-oriented refactoring of
                 JHotDraw.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "GPCE '16 conference proceedings.",
}

@Article{Zhang:2017:ACE,
  author =       "Minjia Zhang and Swarnendu Biswas and Michael D.
                 Bond",
  title =        "Avoiding consistency exceptions under strong memory
                 models",
  journal =      j-SIGPLAN,
  volume =       "52",
  number =       "9",
  pages =        "115--127",
  month =        sep,
  year =         "2017",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3156685.3092271",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Fri Dec 1 18:56:13 MST 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Shared-memory languages and systems generally provide
                 weak or undefined semantics for executions with data
                 races. Prior work has proposed memory consistency
                 models that ensure well-defined, easy-to-understand
                 semantics based on region serializability (RS), but the
                 resulting system may throw a consistency exception in
                 the presence of a data race. Consistency exceptions can
                 occur unexpectedly even in well-tested programs,
                 hurting availability and thus limiting the practicality
                 of RS-based memory models. To our knowledge, this paper
                 is the first to consider the problem of availability
                 for memory consistency models that throw consistency
                 exceptions. We first extend existing approaches that
                 enforce RSx, a memory model based on serializability of
                 synchronization-free regions (SFRs), to avoid region
                 conflicts and thus consistency exceptions. These new
                 approaches demonstrate both the potential for and
                 limitations of avoiding consistency exceptions under
                 RSx. To improve availability further, we introduce (1)
                 a new memory model called RIx based on isolation of
                 SFRs and (2) a new approach called Avalon that provides
                 RIx. We demonstrate two variants of Avalon that offer
                 different performance--availability tradeoffs for RIx.
                 An evaluation on real Java programs shows that this
                 work's novel approaches are able to reduce consistency
                 exceptions, thereby improving the applicability of
                 strong memory consistency models. Furthermore, the
                 approaches provide compelling points in the
                 performance--availability tradeoff space for memory
                 consistency enforcement. RIx and Avalon thus represent
                 a promising direction for tackling the challenge of
                 availability under strong consistency models that throw
                 consistency exceptions.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "ISMM '17 conference proceedings.",
}

@Article{Acar:2018:PCM,
  author =       "Umut A. Acar and Vitaly Aksenov and Arthur
                 Chargu{\'e}raud and Mike Rainey",
  title =        "Performance challenges in modular parallel programs",
  journal =      j-SIGPLAN,
  volume =       "53",
  number =       "1",
  pages =        "381--382",
  month =        jan,
  year =         "2018",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3200691.3178516",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Wed Oct 16 14:12:56 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Over the past decade, many programming languages and
                 systems for parallel-computing have been developed,
                 including Cilk, Fork/Join Java, Habanero Java, Parallel
                 Haskell, Parallel ML, and X10. Although these systems
                 raise the level of abstraction at which parallel code
                 are written, performance continues to require the
                 programmer to perform extensive optimizations and
                 tuning, often by taking various architectural details
                 into account. One such key optimization is granularity
                 control, which requires the programmer to determine
                 when and how parallel tasks should be sequentialized.
                 In this paper, we briefly describe some of the
                 challenges associated with automatic granularity
                 control when trying to achieve portable performance for
                 parallel programs with arbitrary nesting of parallel
                 constructs. We consider a result from the
                 functional-programming community, whose starting point
                 is to consider an ``oracle'' that can predict the work
                 of parallel codes, and thereby control granularity. We
                 discuss the challenges in implementing such an oracle
                 and proving that it has the desired theoretical
                 properties under the nested-parallel programming
                 model.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "PPoPP '18 proceedings.",
}

@Article{Accioly:2018:USS,
  author =       "Paola Accioly and Paulo Borba and Guilherme
                 Cavalcanti",
  title =        "Understanding semi-structured merge conflict
                 characteristics in open-source {Java} projects",
  journal =      j-EMPIR-SOFTWARE-ENG,
  volume =       "23",
  number =       "4",
  pages =        "2051--2085",
  month =        aug,
  year =         "2018",
  CODEN =        "ESENFW",
  DOI =          "https://doi.org/10.1007/s10664-017-9586-1",
  ISSN =         "1382-3256 (print), 1573-7616 (electronic)",
  ISSN-L =       "1382-3256",
  bibdate =      "Wed Sep 26 14:34:26 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/empir-software-eng.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://link.springer.com/article/10.1007/s10664-017-9586-1",
  acknowledgement = ack-nhfb,
  fjournal =     "Empirical Software Engineering",
  journal-URL =  "http://link.springer.com/journal/10664",
}

@Article{Akram:2018:WRG,
  author =       "Shoaib Akram and Jennifer B. Sartor and Kathryn S.
                 McKinley and Lieven Eeckhout",
  title =        "Write-rationing garbage collection for hybrid
                 memories",
  journal =      j-SIGPLAN,
  volume =       "53",
  number =       "4",
  pages =        "62--77",
  month =        apr,
  year =         "2018",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3296979.3192392",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Wed Oct 16 14:12:57 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Emerging Non-Volatile Memory (NVM) technologies offer
                 high capacity and energy efficiency compared to DRAM,
                 but suffer from limited write endurance and longer
                 latencies. Prior work seeks the best of both
                 technologies by combining DRAM and NVM in hybrid
                 memories to attain low latency, high capacity, energy
                 efficiency, and durability. Coarsegrained hardware and
                 OS optimizations then spread writes out (wear-leveling)
                 and place highly mutated pages in DRAM to extend NVM
                 lifetimes. Unfortunately even with these coarse-grained
                 methods, popular Java applications exact impractical
                 NVM lifetimes of 4 years or less. This paper shows how
                 to make hybrid memories practical, without changing the
                 programming model, by enhancing garbage collection in
                 managed language runtimes. We find object write
                 behaviors offer two opportunities: (1) 70\% of writes
                 occur to newly allocated objects, and (2) 2\% of
                 objects capture 81\% of writes to mature objects. We
                 introduce write-rationing garbage collectors that
                 exploit these fine-grained behaviors. They extend NVM
                 lifetimes by placing highly mutated objects in DRAM and
                 read-mostly objects in NVM. We implement two such
                 systems. (1) Kingsguard-nursery places new allocation
                 in DRAM and survivors in NVM, reducing NVM writes by 5$
                 \times $ versus NVM only with wear-leveling. (2)
                 Kingsguard-writers (KG-W) places nursery objects in
                 DRAM and survivors in a DRAM observer space. It
                 monitors all mature object writes and moves unwritten
                 mature objects from DRAM to NVM. Because most mature
                 objects are unwritten, KG-W exploits NVM capacity while
                 increasing NVM lifetimes by 11$ \times $. It reduces
                 the energy-delay product by 32\% over DRAM-only and
                 29\% over NVM-only. This work opens up new avenues for
                 making hybrid memories practical.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "PLDI '18 proceedings.",
}

@Article{Alimadadi:2018:FBP,
  author =       "Saba Alimadadi and Di Zhong and Magnus Madsen and
                 Frank Tip",
  title =        "Finding broken promises in asynchronous {JavaScript}
                 programs",
  journal =      j-PACMPL,
  volume =       "2",
  number =       "OOPSLA",
  pages =        "162:1--162:26",
  month =        oct,
  year =         "2018",
  DOI =          "https://doi.org/10.1145/3276532",
  bibdate =      "Sat Aug 8 07:56:30 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/pacmpl.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3276532",
  abstract =     "Recently, promises were added to ECMAScript 6, the
                 JavaScript standard, in order to provide better support
                 for the asynchrony that arises in user interfaces,
                 network communication, and non-blocking I/O. Using
                 promises, programmers can avoid common pitfalls of
                 event-driven programming such as event races and the
                 deeply nested counterintuitive control ow referred to
                 as ``callback hell''. Unfortunately, promises have
                 complex semantics and the intricate control- and
                 data-flow present in promise-based code hinders program
                 comprehension and can easily lead to bugs. The promise
                 graph was proposed as a graphical aid for understanding
                 and debugging promise-based code. However, it did not
                 cover all promise-related features in ECMAScript 6, and
                 did not present or evaluate any technique for
                 constructing the promise graphs. In this paper, we
                 extend the notion of promise graphs to include all
                 promise-related features in ECMAScript 6, including
                 default reactions, exceptions, and the synchronization
                 operations race and all. Furthermore, we report on the
                 construction and evaluation of PromiseKeeper, which
                 performs a dynamic analysis to create promise graphs
                 and infer common promise anti-patterns. We evaluate
                 PromiseKeeper by applying it to 12 open source
                 promise-based Node.js applications. Our results suggest
                 that the promise graphs constructed by PromiseKeeper
                 can provide developers with valuable information about
                 occurrences of common anti-patterns in their
                 promise-based code, and that promise graphs can be
                 constructed with acceptable run-time overhead.",
  acknowledgement = ack-nhfb,
  articleno =    "162",
  fjournal =     "Proceedings of the ACM on Programming Languages",
  journal-URL =  "https://pacmpl.acm.org/",
}

@Article{Alon:2018:GPB,
  author =       "Uri Alon and Meital Zilberstein and Omer Levy and Eran
                 Yahav",
  title =        "A general path-based representation for predicting
                 program properties",
  journal =      j-SIGPLAN,
  volume =       "53",
  number =       "4",
  pages =        "404--419",
  month =        apr,
  year =         "2018",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3296979.3192412",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Wed Oct 16 14:12:57 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Predicting program properties such as names or
                 expression types has a wide range of applications. It
                 can ease the task of programming, and increase
                 programmer productivity. A major challenge when
                 learning from programs is how to represent programs in
                 a way that facilitates effective learning. We present a
                 general path-based representation for learning from
                 programs. Our representation is purely syntactic and
                 extracted automatically. The main idea is to represent
                 a program using paths in its abstract syntax tree
                 (AST). This allows a learning model to leverage the
                 structured nature of code rather than treating it as a
                 flat sequence of tokens. We show that this
                 representation is general and can: (i) cover different
                 prediction tasks, (ii) drive different learning
                 algorithms (for both generative and discriminative
                 models), and (iii) work across different programming
                 languages. We evaluate our approach on the tasks of
                 predicting variable names, method names, and full
                 types. We use our representation to drive both
                 CRF-based and word2vec-based learning, for programs of
                 four languages: JavaScript, Java, Python and C\#. Our
                 evaluation shows that our approach obtains better
                 results than task-specific handcrafted representations
                 across different tasks and programming languages.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "PLDI '18 proceedings.",
}

@Article{Anonymous:2018:BRS,
  author =       "Anonymous",
  title =        "Book Review: {{\booktitle{Simplifying JavaScript}}, by
                 Joe Morgan. Published by Pragmatic Bookshelf. ISBN:
                 978-1-68050-288-6. Price: \$39.95, 282 pgs,
                 paperback}",
  journal =      j-NETWORK-SECURITY,
  volume =       "2018",
  number =       "5",
  pages =        "5--5",
  month =        may,
  year =         "2018",
  CODEN =        "NTSCF5",
  ISSN =         "1353-4858 (print), 1872-9371 (electronic)",
  ISSN-L =       "1353-4858",
  bibdate =      "Thu Sep 12 12:57:51 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/network-security.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S1353485818300412",
  acknowledgement = ack-nhfb,
  fjournal =     "Network Security",
  journal-URL =  "https://www.sciencedirect.com/journal/network-security",
}

@Article{Bastani:2018:ALP,
  author =       "Osbert Bastani and Rahul Sharma and Alex Aiken and
                 Percy Liang",
  title =        "Active learning of points-to specifications",
  journal =      j-SIGPLAN,
  volume =       "53",
  number =       "4",
  pages =        "678--692",
  month =        apr,
  year =         "2018",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3296979.3192383",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Wed Oct 16 14:12:57 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "When analyzing programs, large libraries pose
                 significant challenges to static points-to analysis. A
                 popular solution is to have a human analyst provide
                 points-to specifications that summarize relevant
                 behaviors of library code, which can substantially
                 improve precision and handle missing code such as
                 native code. We propose Atlas, a tool that
                 automatically infers points-to specifications. Atlas
                 synthesizes unit tests that exercise the library code,
                 and then infers points-to specifications based on
                 observations from these executions. Atlas automatically
                 infers specifications for the Java standard library,
                 and produces better results for a client static
                 information flow analysis on a benchmark of 46 Android
                 apps compared to using existing handwritten
                 specifications.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "PLDI '18 proceedings.",
}

@Article{Baxter:2018:PAS,
  author =       "Samuel Baxter and Rachit Nigam and Joe Gibbs Politz
                 and Shriram Krishnamurthi and Arjun Guha",
  title =        "Putting in all the stops: execution control for
                 {JavaScript}",
  journal =      j-SIGPLAN,
  volume =       "53",
  number =       "4",
  pages =        "30--45",
  month =        apr,
  year =         "2018",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3296979.3192370",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Wed Oct 16 14:12:57 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Scores of compilers produce JavaScript, enabling
                 programmers to use many languages on the Web, reuse
                 existing code, and even use Web IDEs. Unfortunately,
                 most compilers inherit the browser's compromised
                 execution model, so long-running programs freeze the
                 browser tab, infinite loops crash IDEs, and so on. The
                 few compilers that avoid these problems suffer poor
                 performance and are difficult to engineer. This paper
                 presents Stopify, a source-to-source compiler that
                 extends JavaScript with debugging abstractions and
                 blocking operations, and easily integrates with
                 existing compilers. We apply Stopify to ten programming
                 languages and develop a Web IDE that supports stopping,
                 single-stepping, breakpointing, and long-running
                 computations. For nine languages, Stopify requires no
                 or trivial compiler changes. For eight, our IDE is the
                 first that provides these features. Two of our subject
                 languages have compilers with similar features.
                 Stopify's performance is competitive with these
                 compilers and it makes them dramatically simpler.
                 Stopify's abstractions rely on first-class
                 continuations, which it provides by compiling
                 JavaScript to JavaScript. We also identify
                 sub-languages of JavaScript that compilers implicitly
                 use, and exploit these to improve performance. Finally,
                 Stopify needs to repeatedly interrupt and resume
                 program execution. We use a sampling-based technique to
                 estimate program speed that outperforms other
                 systems.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "PLDI '18 proceedings.",
}

@Article{Black:2018:NPJ,
  author =       "N. Black",
  title =        "{Nicolai Parlog} on {Java 9} Modules",
  journal =      j-IEEE-SOFTWARE,
  volume =       "35",
  number =       "3",
  pages =        "101--104",
  month =        may # "\slash " # jun,
  year =         "2018",
  CODEN =        "IESOEG",
  DOI =          "https://doi.org/10.1109/MS.2018.2141025",
  ISSN =         "0740-7459 (print), 1937-4194 (electronic)",
  ISSN-L =       "0740-7459",
  bibdate =      "Fri Aug 2 09:25:48 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ieeesoft.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE Software",
  journal-URL =  "http://www.computer.org/portal/web/csdl/magazines/software",
  keywords =     "Interviews; JAR; Java; Java 9; Java archives; Java
                 modules; Java Platform Module System; JPMS; Nicolai
                 Parlog; Runtime; Software development; software
                 development; software engineering; Software Engineering
                 Radio",
}

@Article{Blackshear:2018:RCS,
  author =       "Sam Blackshear and Nikos Gorogiannis and Peter W.
                 O'Hearn and Ilya Sergey",
  title =        "{RacerD}: compositional static race detection",
  journal =      j-PACMPL,
  volume =       "2",
  number =       "OOPSLA",
  pages =        "144:1--144:28",
  month =        oct,
  year =         "2018",
  DOI =          "https://doi.org/10.1145/3276514",
  bibdate =      "Sat Aug 8 07:56:30 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/pacmpl.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3276514",
  abstract =     "Automatic static detection of data races is one of the
                 most basic problems in reasoning about concurrency. We
                 present RacerD-a static program analysis for detecting
                 data races in Java programs which is fast, can scale to
                 large code, and has proven \ldots{}",
  acknowledgement = ack-nhfb,
  articleno =    "144",
  fjournal =     "Proceedings of the ACM on Programming Languages",
  journal-URL =  "https://pacmpl.acm.org/",
}

@Article{Boldi:2018:BMC,
  author =       "Paolo Boldi and Andrea Marino and Massimo Santini and
                 Sebastiano Vigna",
  title =        "{BUbiNG}: Massive Crawling for the Masses",
  journal =      j-TWEB,
  volume =       "12",
  number =       "2",
  pages =        "12:1--12:26",
  month =        jun,
  year =         "2018",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/3160017",
  ISSN =         "1559-1131 (print), 1559-114X (electronic)",
  ISSN-L =       "1559-1131",
  bibdate =      "Thu Jun 28 14:10:01 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/pagerank.bib;
                 https://www.math.utah.edu/pub/tex/bib/tweb.bib",
  URL =          "https://dl.acm.org/citation.cfm?doid=3176641.3160017",
  abstract =     "Although web crawlers have been around for twenty
                 years by now, there is virtually no freely available,
                 open-source crawling software that guarantees high
                 throughput, overcomes the limits of single-machine
                 systems, and, at the same time, scales linearly with
                 the amount of resources available. This article aims at
                 filling this gap, through the description of BUbiNG,
                 our next-generation web crawler built upon the authors'
                 experience with UbiCrawler [9] and on the last ten
                 years of research on the topic. BUbiNG is an
                 open-source Java fully distributed crawler; a single
                 BUbiNG agent, using sizeable hardware, can crawl
                 several thousand pages per second respecting strict
                 politeness constraints, both host- and IP-based. Unlike
                 existing open-source distributed crawlers that rely on
                 batch techniques (like MapReduce), BUbiNG job
                 distribution is based on modern high-speed protocols to
                 achieve very high throughput.",
  acknowledgement = ack-nhfb,
  articleno =    "12",
  fjournal =     "ACM Transactions on the Web (TWEB)",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J1062",
  keywords =     "BUbiNG; centrality measures; distributed systems;
                 Java; PageRank; UbiCrawler; Web crawling",
}

@Article{Bouraqadi:2018:TDD,
  author =       "Noury Bouraqadi and Dave Mason",
  title =        "Test-driven development for generated portable
                 {Javascript} apps",
  journal =      j-SCI-COMPUT-PROGRAM,
  volume =       "161",
  number =       "??",
  pages =        "2--17",
  month =        "????",
  year =         "2018",
  CODEN =        "SCPGD4",
  DOI =          "https://doi.org/10.1016/j.scico.2018.02.003",
  ISSN =         "0167-6423 (print), 1872-7964 (electronic)",
  ISSN-L =       "0167-6423",
  bibdate =      "Tue May 29 05:45:13 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/scicomputprogram.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0167642318300595",
  acknowledgement = ack-nhfb,
  fjournal =     "Science of Computer Programming",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01676423",
}

@Article{Brachthauser:2018:EHM,
  author =       "Jonathan Immanuel Brachth{\"a}user and Philipp
                 Schuster and Klaus Ostermann",
  title =        "Effect handlers for the masses",
  journal =      j-PACMPL,
  volume =       "2",
  number =       "OOPSLA",
  pages =        "111:1--111:27",
  month =        oct,
  year =         "2018",
  DOI =          "https://doi.org/10.1145/3276481",
  bibdate =      "Sat Aug 8 07:56:30 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/pacmpl.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3276481",
  abstract =     "Effect handlers are a program structuring paradigm
                 with rising popularity in the functional programming
                 language community and can express many advanced
                 control flow abstractions. We present the first
                 implementation of effect handlers for Java --- an
                 \ldots{}",
  acknowledgement = ack-nhfb,
  articleno =    "111",
  fjournal =     "Proceedings of the ACM on Programming Languages",
  journal-URL =  "https://pacmpl.acm.org/",
}

@Article{Bruno:2018:DVM,
  author =       "Rodrigo Bruno and Paulo Ferreira and Ruslan Synytsky
                 and Tetiana Fydorenchyk and Jia Rao and Hang Huang and
                 Song Wu",
  title =        "Dynamic vertical memory scalability for {OpenJDK}
                 cloud applications",
  journal =      j-SIGPLAN,
  volume =       "53",
  number =       "5",
  pages =        "59--70",
  month =        may,
  year =         "2018",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3299706.3210567",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Wed Oct 16 14:12:58 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "The cloud is an increasingly popular platform to
                 deploy applications as it lets cloud users to provide
                 resources to their applications as needed. Furthermore,
                 cloud providers are now starting to offer a
                 ``pay-as-you-use'' model in which users are only
                 charged for the resources that are really used instead
                 of paying for a statically sized instance. This new
                 model allows cloud users to save money, and cloud
                 providers to better utilize their hardware. However,
                 applications running on top of runtime environments
                 such as the Java Virtual Machine (JVM) cannot benefit
                 from this new model because they cannot dynamically
                 adapt the amount of used resources at runtime. In
                 particular, if an application needs more memory than
                 what was initially predicted at launch time, the JVM
                 will not allow the application to grow its memory
                 beyond the maximum value defined at launch time. In
                 addition, the JVM will hold memory that is no longer
                 being used by the application. This lack of dynamic
                 vertical scalability completely prevents the benefits
                 of the ``pay-as-you-use'' model, and forces users to
                 over-provision resources, and to lose money on unused
                 resources. We propose a new JVM heap sizing strategy
                 that allows the JVM to dynamically scale its memory
                 utilization according to the application's needs.
                 First, we provide a configurable limit on how much the
                 application can grow its memory. This limit is dynamic
                 and can be changed at runtime, as opposed to the
                 current static limit that can only be set at launch
                 time. Second, we adapt current Garbage Collection
                 policies that control how much the heap can grow and
                 shrink to better fit what is currently being used by
                 the application. The proposed solution is implemented
                 in the OpenJDK 9 HotSpot JVM, the new release of
                 OpenJDK. Changes were also introduced inside the
                 Parallel Scavenge collector and the Garbage First
                 collector (the new by-default collector in HotSpot).
                 Evaluation experiments using real workloads and data
                 show that, with negligible throughput and memory
                 overhead, dynamic vertical memory scalability can be
                 achieved. This allows users to save significant amounts
                 of money by not paying for unused resources, and cloud
                 providers to better utilize their physical machines.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "ISMM '18 proceedings.",
}

@Article{Bruno:2018:SGC,
  author =       "Rodrigo Bruno and Paulo Ferreira",
  title =        "A Study on Garbage Collection Algorithms for Big Data
                 Environments",
  journal =      j-COMP-SURV,
  volume =       "51",
  number =       "1",
  pages =        "20:1--20:??",
  month =        apr,
  year =         "2018",
  CODEN =        "CMSVAN",
  DOI =          "https://doi.org/10.1145/3156818",
  ISSN =         "0360-0300 (print), 1557-7341 (electronic)",
  ISSN-L =       "0360-0300",
  bibdate =      "Sat Aug 31 09:04:34 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/compsurv.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "The need to process and store massive amounts of
                 data-Big Data-is a reality. In areas such as scientific
                 experiments, social networks management, credit card
                 fraud detection, targeted advertisement, and financial
                 analysis, massive amounts of information are generated
                 and processed daily to extract valuable, summarized
                 information. Due to its fast development cycle (i.e.,
                 less expensive to develop), mainly because of automatic
                 memory management, and rich community resources,
                 managed object-oriented programming languages (e.g.,
                 Java) are the first choice to develop Big Data
                 platforms (e.g., Cassandra, Spark) on which such Big
                 Data applications are executed. However, automatic
                 memory management comes at a cost. This cost is
                 introduced by the garbage collector, which is
                 responsible for collecting objects that are no longer
                 being used. Although current (classic) garbage
                 collection algorithms may be applicable to small-scale
                 applications, these algorithms are not appropriate for
                 large-scale Big Data environments, as they do not scale
                 in terms of throughput and pause times. In this work,
                 current Big Data platforms and their memory profiles
                 are studied to understand why classic algorithms (which
                 are still the most commonly used) are not appropriate,
                 and also to analyze recently proposed and relevant
                 memory management algorithms, targeted to Big Data
                 environments. The scalability of recent memory
                 management algorithms is characterized in terms of
                 throughput (improves the throughput of the application)
                 and pause time (reduces the latency of the application)
                 when compared to classic algorithms. The study is
                 concluded by presenting a taxonomy of the described
                 works and some open problems, with regard to Big Data
                 memory management, that could be addressed in future
                 works.",
  acknowledgement = ack-nhfb,
  articleno =    "20",
  fjournal =     "ACM Computing Surveys",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J204",
}

@Article{Bultan:2018:SCA,
  author =       "Tevfik Bultan",
  title =        "Side-Channel Analysis via Symbolic Execution and Model
                 Counting",
  journal =      j-SIGSOFT,
  volume =       "43",
  number =       "4",
  pages =        "55--55",
  month =        oct,
  year =         "2018",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/3282517.3302416",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Sat Oct 19 18:11:10 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  abstract =     "An important problem in computer security is the
                 detection of side-channel vulnerabilities. Information
                 gained by observing nonfunctional properties of program
                 executions (i.e., sidechannels such as execution time
                 or memory usage) can enable attackers to infer secrets
                 that the program accesses (such as a password). In this
                 talk, I will discuss how symbolic execution, combined
                 with a model counting constraint solver, can be used
                 for quantifying side-channel leakage in Java programs.
                 I will also discuss automata-based model counting
                 techniques. We have implemented these techniques by
                 integrating our model counting constraint solver,
                 called Automata-Based model Counter (ABC), with the
                 symbolic execution tool Symbolic Path Finder (SPF).",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Chadha:2018:JAS,
  author =       "Gaurav Chadha",
  title =        "{JSCore}: architectural support for accelerating
                 {JavaScript} execution (short {WIP} paper)",
  journal =      j-SIGPLAN,
  volume =       "53",
  number =       "6",
  pages =        "104--108",
  month =        jun,
  year =         "2018",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3299710.3211343",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Wed Oct 16 14:12:58 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "JavaScript has seen meteoric growth in popularity as
                 it has increasingly become the language of choice for
                 developers, both for front-end web development and
                 server code development through various JavaScript
                 frameworks and Node.js. Part of the reason for its wide
                 use is that it is a prototype based language with
                 dynamic types, making it easy to learn and program in.
                 This flexibility and ease of programming comes at the
                 cost of performance. There are two sources of
                 significant slowdown. First, since the number and type
                 of properties of prototypes is dynamic, accessing a
                 property involves a slow dictionary lookup, as opposed
                 to it being present at a fixed offset from the base
                 address. Second, the dynamism in type of values
                 necessitates wrapping and unwrapping of values into
                 objects with a variety of checks including for type of
                 the value. To mitigate these performance problems, this
                 paper proposes JSCore, a core specialized for
                 JavaScript execution, that vastly reduces the
                 performance degradation due to the above two causes. It
                 uses a hardware lookup table to accelerate property
                 access, and extends the data path to store data types
                 with the data, nearly eliminating the second source of
                 slowdown. Combining the two, JSCore accelerates real
                 world JavaScript applications by 23\%.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "LCTES '18 proceedings.",
}

@Article{Christophe:2018:ODA,
  author =       "Laurent Christophe and Coen {De Roover} and Elisa
                 Gonzalez Boix and Wolfgang {De Meuter}",
  title =        "Orchestrating dynamic analyses of distributed
                 processes for full-stack {JavaScript} programs",
  journal =      j-SIGPLAN,
  volume =       "53",
  number =       "9",
  pages =        "107--118",
  month =        nov,
  year =         "2018",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3393934.3278135",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Wed Apr 8 13:49:51 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3393934.3278135",
  abstract =     "Dynamic analyses are commonly implemented by
                 instrumenting the program under analysis. Examples of
                 such analyses for JavaScript range from checkers of
                 user- defined invariants to concolic testers. For a
                 full-stack JavaScript program, these analyses
                 \ldots{}",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "https://dl.acm.org/loi/sigplan",
}

@Article{Cordeiro:2018:BJV,
  author =       "Lucas C. Cordeiro and Daniel Kroening and Peter
                 Schrammel",
  title =        "Benchmarking of {Java} Verification Tools at the
                 {Software Verification Competition (SV-COMP)}",
  journal =      j-SIGSOFT,
  volume =       "43",
  number =       "4",
  pages =        "56--56",
  month =        oct,
  year =         "2018",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/3282517.3282529",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Sat Oct 19 18:11:10 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  abstract =     "Empirical evaluation of verification tools by
                 benchmarking is a common method in software
                 verification research. The Competition on Software
                 Verification (SV-COMP) aims at standardization and
                 reproducibility of benchmarking within the software
                 verification community in an annual basis, through
                 comparative evaluation of fully-automatic software
                 verifiers for C programs. Building upon this success,
                 we describe here how to re-use the ecosystem developed
                 around SV-COMP for benchmarking Java verification
                 tools. We provide a detailed description of the rules
                 for benchmark verification tasks, the integration of
                 new tools into SV-COMP's benchmarking framework and
                 also give experimental results of a benchmarking run on
                 three state-of-the-art Java verification tools, JPF-SE,
                 JayHorn and JBMC.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Daloze:2018:PDL,
  author =       "Benoit Daloze and Arie Tal and Stefan Marr and
                 Hanspeter M{\"o}ssenb{\"o}ck and Erez Petrank",
  title =        "Parallelization of dynamic languages: synchronizing
                 built-in collections",
  journal =      j-PACMPL,
  volume =       "2",
  number =       "OOPSLA",
  pages =        "108:1--108:30",
  month =        oct,
  year =         "2018",
  DOI =          "https://doi.org/10.1145/3276478",
  bibdate =      "Sat Aug 8 07:56:30 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/hash.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/pacmpl.bib;
                 https://www.math.utah.edu/pub/tex/bib/python.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3276478",
  abstract =     "Dynamic programming languages such as Python and Ruby
                 are widely used, and much effort is spent on making
                 them efficient. One substantial research effort in this
                 direction is the enabling of parallel code execution.
                 While there has been significant progress, making
                 dynamic collections efficient, scalable, and
                 thread-safe is an open issue. Typical programs in
                 dynamic languages use few but versatile collection
                 types. Such collections are an important ingredient of
                 dynamic environments, but are difficult to make safe,
                 efficient, and scalable.\par

                 In this paper, we propose an approach for efficient and
                 concurrent collections by gradually increasing
                 synchronization levels according to the dynamic needs
                 of each collection instance. Collections reachable only
                 by a single thread have no synchronization, arrays
                 accessed in bounds have minimal synchronization, and
                 for the general case, we adopt the Layout Lock paradigm
                 and extend its design with a lightweight version that
                 fits the setting of dynamic languages. We apply our
                 approach to Ruby's Array and Hash collections. Our
                 experiments show that our approach has no overhead on
                 single-threaded benchmarks, scales linearly for Array
                 and Hash accesses, achieves the same scalability as
                 Fortran and Java for classic parallel algorithms, and
                 scales better than other Ruby implementations on Ruby
                 workloads",
  acknowledgement = ack-nhfb,
  articleno =    "108",
  fjournal =     "Proceedings of the ACM on Programming Languages",
  journal-URL =  "https://pacmpl.acm.org/",
}

@Book{Dan:2018:LJE,
  author =       "Toomey Dan",
  title =        "Learning {Jupyter 5}: explore interactive computing
                 using {Python}, {Java}, {JavaScript}, {R}, {Julia}, and
                 {JupyterLab}",
  publisher =    pub-PACKT,
  address =      pub-PACKT:adr,
  pages =        "282",
  year =         "2018",
  ISBN =         "1-78913-740-3, 1-78913-744-6",
  ISBN-13 =      "978-1-78913-740-8, 978-1-78913-744-6",
  LCCN =         "Q183.9; QA76.9.I52 .T666 2018",
  bibdate =      "Fri Apr 9 05:38:17 MDT 2021",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/julia.bib;
                 https://www.math.utah.edu/pub/tex/bib/python.bib;
                 https://www.math.utah.edu/pub/tex/bib/s-plus.bib",
  acknowledgement = ack-nhfb,
  tableofcontents = "Preface \\
                 1: Introduction to Jupyter \\
                 First look at Jupyter \\
                 Installing Jupyter \\
                 Notebook structure \\
                 Notebook workflow \\
                 Basic Notebook operations \\
                 File operations \\
                 Duplicate \\
                 Rename \\
                 Delete \\
                 Upload \\
                 New text file \\
                 New folder \\
                 New Python 3 \\
                 Security in Jupyter \\
                 Security digest \\
                 Trust options \\
                 Configuration options for Jupyter \\
                 Summary \\
                 2: Jupyter Python Scripting \\
                 Basic Python in Jupyter \\
                 Python data access in Jupyter \\
                 Python pandas in Jupyter \\
                 Python graphics in Jupyter \\
                 Python random numbers in Jupyter \\
                 Summary \\
                 3: Jupyter R Scripting \\
                 Adding R scripting to your installation \\
                 Adding R scripts to Jupyter on macOS \\
                 Adding R scripts to Jupyter on Windows \\
                 Adding R packages to Jupyter \\
                 R limitations in Jupyter \\
                 Basic R in Jupyter \\
                 R dataset access \\
                 R visualizations in Jupyter \\
                 R 3D graphics in Jupyter \\
                 R 3D scatterplot in Jupyter \\
                 R cluster analysis \\
                 R forecasting \\
                 R machine learning \\
                 Dataset \\
                 Summary \\
                 4: Jupyter Julia Scripting \\
                 Adding Julia scripting to your installation \\
                 Adding Julia scripts to Jupyter \\
                 Adding Julia packages to Jupyter \\
                 Basic Julia in Jupyter \\
                 Julia limitations in Jupyter \\
                 Standard Julia capabilities \\
                 Julia visualizations in Jupyter \\
                 Julia Gadfly scatterplot \\
                 Julia Gadfly histogram \\
                 Julia Winston plotting \\
                 Julia Vega plotting \\
                 Julia PyPlot plotting \\
                 Julia parallel processing \\
                 Julia control flow \\
                 Julia regular expressions \\
                 Julia unit testing \\
                 Summary \\
                 5: Jupyter Java Coding \\
                 Adding the Java kernel to your installation \\
                 Installing Java 9 or later \\
                 A Jupyter environment is required \\
                 Configuring IJava \\
                 Downloading the IJava project from GitHub \\
                 Building and installing the kernel \\
                 Available options \\
                 Jupyter Java console \\
                 Jupyter Java output \\
                 Java Optional \\
                 Java compiler errors \\
                 Java lambdas \\
                 Java Collections \\
                 Java streams \\
                 Java summary statistics \\
                 Summary \\
                 6: Jupyter JavaScript Coding \\
                 Adding JavaScript scripting to your installation \\
                 Adding JavaScript scripts to Jupyter on macOS or
                 Windows \\
                 JavaScript Hello World Jupyter Notebook \\
                 Adding JavaScript packages to Jupyter \\
                 Basic JavaScript in Jupyter \\
                 JavaScript limitations in Jupyter \\
                 Node.js d3 package \\
                 Node.js stats-analysis package \\
                 Node.js JSON handling \\
                 Node.js canvas package \\
                 Node.js plotly package \\
                 Node.js asynchronous threadsNode.js decision-tree
                 package \\
                 Summary \\
                 7: Jupyter Scala \\
                 Installing the Scala kernel \\
                 Scala data access in Jupyter \\
                 Scala array operations \\
                 Scala random numbers in Jupyter \\
                 Scala closures \\
                 Scala higher-order functions \\
                 Scala pattern matching \\
                 Scala case classes \\
                 Scala immutability \\
                 Scala collections \\
                 Named arguments \\
                 Scala traits \\
                 Summary \\
                 8: Jupyter and Big Data \\
                 Apache Spark \\
                 Installing Spark on macOS \\
                 Windows install \\
                 First Spark script \\
                 Spark word count \\
                 Sorted word count \\
                 Estimate pi \\
                 Log file examination \\
                 Spark primes \\
                 Spark text file analysis",
}

@Article{deJong:2018:MJA,
  author =       "Jos de Jong and Eric Mansfield",
  title =        "{Math.Js}: An Advanced Mathematics Library For
                 {JavaScript}",
  journal =      j-COMPUT-SCI-ENG,
  volume =       "20",
  number =       "1",
  pages =        "20--32",
  month =        "????",
  year =         "2018",
  CODEN =        "CSENFA",
  DOI =          "https://doi.org/10.1109/MCSE.2018.011111122",
  ISSN =         "1521-9615 (print), 1558-366X (electronic)",
  ISSN-L =       "1521-9615",
  bibdate =      "Thu Feb 15 06:20:46 MST 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/computscieng.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://ieeexplore.ieee.org/document/8291769/",
  acknowledgement = ack-nhfb,
  journal-URL =  "http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=5992",
}

@Article{Dennis:2018:MFI,
  author =       "Louise A. Dennis",
  title =        "The {MCAPL} Framework including the {Agent
                 Infrastructure Layer} and {Agent Java Pathfinder}",
  journal =      j-J-OPEN-SOURCE-SOFT,
  volume =       "3",
  number =       "24",
  pages =        "617:1--617:2",
  month =        apr,
  year =         "2018",
  CODEN =        "????",
  DOI =          "https://doi.org/10.21105/joss.00617",
  ISSN =         "2475-9066",
  ISSN-L =       "2475-9066",
  bibdate =      "Thu Sep 13 08:09:35 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/joss.bib",
  URL =          "http://joss.theoj.org/papers/10.21105/joss.00617",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Open Source Software",
  journal-URL =  "http://joss.theoj.org/;
                 https://github.com/openjournals/joss-papers/",
  onlinedate =   "30 April 2018",
}

@Article{DiPierro:2018:RJ,
  author =       "Massimo DiPierro",
  title =        "The Rise of {JavaScript}",
  journal =      j-COMPUT-SCI-ENG,
  volume =       "20",
  number =       "1",
  pages =        "9--10",
  month =        "????",
  year =         "2018",
  CODEN =        "CSENFA",
  DOI =          "https://doi.org/10.1109/MCSE.2018.011111120",
  ISSN =         "1521-9615 (print), 1558-366X (electronic)",
  ISSN-L =       "1521-9615",
  bibdate =      "Thu Feb 15 06:20:46 MST 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/computscieng.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  journal-URL =  "http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=5992",
}

@Article{DiPierro:2018:TVG,
  author =       "Massimo DiPierro",
  title =        "Toy Vision-Guided {$3$D} Robotic Arm in {JavaScript}",
  journal =      j-COMPUT-SCI-ENG,
  volume =       "20",
  number =       "1",
  pages =        "43--49",
  month =        "????",
  year =         "2018",
  CODEN =        "CSENFA",
  DOI =          "https://doi.org/10.1109/MCSE.2018.011111124",
  ISSN =         "1521-9615 (print), 1558-366X (electronic)",
  ISSN-L =       "1521-9615",
  bibdate =      "Thu Feb 15 06:20:46 MST 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/computscieng.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://ieeexplore.ieee.org/document/8291773/",
  acknowledgement = ack-nhfb,
  journal-URL =  "http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=5992",
}

@Article{Fan:2018:VCJ,
  author =       "Linyu Fan and Jianwei Liao and Junsen Zuo and Kebo
                 Zhang and Chao Li and Hailing Xiong",
  title =        "Version 4.0 of code {Java} for {$3$D} simulation of
                 the {CCA} model",
  journal =      j-COMP-PHYS-COMM,
  volume =       "228",
  number =       "??",
  pages =        "290--292",
  month =        jul,
  year =         "2018",
  CODEN =        "CPHCBZ",
  DOI =          "https://doi.org/10.1016/j.cpc.2018.03.014",
  ISSN =         "0010-4655 (print), 1879-2944 (electronic)",
  ISSN-L =       "0010-4655",
  bibdate =      "Thu May 31 14:21:46 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/compphyscomm2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0010465518300869",
  acknowledgement = ack-nhfb,
  fjournal =     "Computer Physics Communications",
  journal-URL =  "http://www.sciencedirect.com/science/journal/00104655",
}

@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,
  articleno =    "8",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Gupta:2018:HDB,
  author =       "Shashank Gupta and B. B. Gupta and Pooja Chaudhary",
  title =        "Hunting for {DOM}-Based {XSS} vulnerabilities in
                 mobile cloud-based online social network",
  journal =      j-FUT-GEN-COMP-SYS,
  volume =       "79 (part 1)",
  number =       "??",
  pages =        "319--336",
  year =         "2018",
  CODEN =        "FGSEVI",
  DOI =          "https://doi.org/10.1016/j.future.2017.05.038",
  ISSN =         "0167-739X (print), 1872-7115 (electronic)",
  ISSN-L =       "0167-739X",
  bibdate =      "Fri Nov 24 15:16:17 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/futgencompsys.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "https://www.sciencedirect.com/science/article/pii/S0167739X17311068",
  acknowledgement = ack-nhfb,
  fjournal =     "Future Generation Computer Systems",
  journal-URL =  "http://www.sciencedirect.com/science/journal/0167739X",
  keywords =     "Cross-site scripting (XSS) worms; Document Object
                 Model (DOM) tree; DOM-Based {XSS} attacks; HTML5;
                 JavaScript code injection attacks; Mobile cloud
                 computing",
}

@Article{Herrera:2018:NCW,
  author =       "David Herrera and Hanfeng Chen and Erick Lavoie and
                 Laurie Hendren",
  title =        "Numerical computing on the web: benchmarking for the
                 future",
  journal =      j-SIGPLAN,
  volume =       "53",
  number =       "8",
  pages =        "88--100",
  month =        oct,
  year =         "2018",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3393673.3276968",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Wed Apr 8 13:49:51 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3393673.3276968",
  abstract =     "Recent advances in execution environments for
                 JavaScript and WebAssembly that run on a broad range of
                 devices, from workstations and mobile phones to IoT
                 devices, provide new opportunities for portable and
                 web-based numerical computing. Indeed, numerous
                 \ldots{}",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "https://dl.acm.org/loi/sigplan",
}

@Article{Insa:2018:AAJ,
  author =       "David Insa and Josep Silva",
  title =        "Automatic assessment of {Java} code",
  journal =      j-COMP-LANGS-SYS-STRUCT,
  volume =       "53",
  number =       "??",
  pages =        "59--72",
  month =        sep,
  year =         "2018",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1016/j.cl.2018.01.004",
  ISSN =         "1477-8424 (print), 1873-6866 (electronic)",
  ISSN-L =       "1477-8424",
  bibdate =      "Mon Apr 16 13:30:38 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/complngs.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S1477842417301045",
  acknowledgement = ack-nhfb,
  fjournal =     "Computer Languages, Systems and Structures",
  journal-URL =  "http://www.sciencedirect.com/science/journal/14778424/",
}

@Article{Kintis:2018:HEM,
  author =       "Marinos Kintis and Mike Papadakis and Andreas
                 Papadopoulos and Evangelos Valvis and Nicos Malevris
                 and Yves {Le Traon}",
  title =        "How effective are mutation testing tools? {An}
                 empirical analysis of {Java} mutation testing tools
                 with manual analysis and real faults",
  journal =      j-EMPIR-SOFTWARE-ENG,
  volume =       "23",
  number =       "4",
  pages =        "2426--2463",
  month =        aug,
  year =         "2018",
  CODEN =        "ESENFW",
  DOI =          "https://doi.org/10.1007/s10664-017-9582-5",
  ISSN =         "1382-3256 (print), 1573-7616 (electronic)",
  ISSN-L =       "1382-3256",
  bibdate =      "Wed Sep 26 14:34:26 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/empir-software-eng.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://link.springer.com/article/10.1007/s10664-017-9582-5",
  acknowledgement = ack-nhfb,
  fjournal =     "Empirical Software Engineering",
  journal-URL =  "http://link.springer.com/journal/10664",
}

@Article{Knoche:2018:UML,
  author =       "H. Knoche and W. Hasselbring",
  title =        "Using Microservices for Legacy Software
                 Modernization",
  journal =      j-IEEE-SOFTWARE,
  volume =       "35",
  number =       "3",
  pages =        "44--49",
  month =        may # "\slash " # jun,
  year =         "2018",
  CODEN =        "IESOEG",
  DOI =          "https://doi.org/10.1109/MS.2018.2141035",
  ISSN =         "0740-7459 (print), 1937-4194 (electronic)",
  ISSN-L =       "0740-7459",
  bibdate =      "Fri Aug 2 09:25:48 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ieeesoft.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE Software",
  journal-URL =  "http://www.computer.org/portal/web/csdl/magazines/software",
  keywords =     "cloud computing; Computer architecture; Databases;
                 Java; legacy modernization project; legacy software
                 modernization; microservices; migration process;
                 scalable applications; Service computing; services
                 modernization; smaller code bases; Software
                 development; software development; Software
                 engineering; software engineering; software
                 maintenance; web services; Web services",
}

@Article{Kouzapas:2018:TPM,
  author =       "Dimitrios Kouzapas and Ornela Dardha and Roly Perera
                 and Simon J. Gay",
  title =        "Typechecking protocols with {Mungo} and {StMungo}: A
                 session type toolchain for {Java}",
  journal =      j-SCI-COMPUT-PROGRAM,
  volume =       "155",
  number =       "??",
  pages =        "52--75",
  month =        "????",
  year =         "2018",
  CODEN =        "SCPGD4",
  DOI =          "https://doi.org/10.1016/j.scico.2017.10.006",
  ISSN =         "0167-6423 (print), 1872-7964 (electronic)",
  ISSN-L =       "0167-6423",
  bibdate =      "Sat Mar 17 18:00:23 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/scicomputprogram.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0167642317302186",
  acknowledgement = ack-nhfb,
  fjournal =     "Science of Computer Programming",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01676423",
}

@Article{Larrucea:2018:M,
  author =       "X. Larrucea and I. Santamaria and R. Colomo-Palacios
                 and C. Ebert",
  title =        "Microservices",
  journal =      j-IEEE-SOFTWARE,
  volume =       "35",
  number =       "3",
  pages =        "96--100",
  month =        may # "\slash " # jun,
  year =         "2018",
  CODEN =        "IESOEG",
  DOI =          "https://doi.org/10.1109/MS.2018.2141030",
  ISSN =         "0740-7459 (print), 1937-4194 (electronic)",
  ISSN-L =       "0740-7459",
  bibdate =      "Fri Aug 2 09:25:48 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ieeesoft.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE Software",
  journal-URL =  "http://www.computer.org/portal/web/csdl/magazines/software",
  keywords =     "agile delivery mechanisms; Browsers; Computer
                 architecture; CORS; Cross-Origin Resource Sharing;
                 flexible service orientation; function-oriented legacy
                 architectures; Java; microservice technologies;
                 microservices; Service computing; service-oriented
                 architecture; Software development; software
                 development; software engineering; Software Technology;
                 Web services",
}

@Article{Lauinger:2018:TSD,
  author =       "Tobias Lauinger and Abdelberi Chaabane and Christo B.
                 Wilson",
  title =        "Thou shalt not depend on me",
  journal =      j-CACM,
  volume =       "61",
  number =       "6",
  pages =        "41--47",
  month =        jun,
  year =         "2018",
  CODEN =        "CACMA2",
  DOI =          "https://doi.org/10.1145/3190562",
  ISSN =         "0001-0782 (print), 1557-7317 (electronic)",
  ISSN-L =       "0001-0782",
  bibdate =      "Tue Jun 5 14:47:04 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/cacm2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "https://cacm.acm.org/magazines/2018/6/228039/fulltext",
  abstract =     "A look at JavaScript libraries in the wild.",
  acknowledgement = ack-nhfb,
  fjournal =     "Communications of the ACM",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J79",
}

@Article{Li:2018:ATJ,
  author =       "Bing Li and Xueli Xiao and Yi Pan",
  title =        "Automatic translation from {Java} to {Spark}",
  journal =      j-CCPE,
  volume =       "30",
  number =       "20",
  pages =        "e4459:1--e4459:??",
  day =          "25",
  month =        oct,
  year =         "2018",
  CODEN =        "CCPEBO",
  DOI =          "https://doi.org/10.1002/cpe.4459",
  ISSN =         "1532-0626 (print), 1532-0634 (electronic)",
  ISSN-L =       "1532-0626",
  bibdate =      "Thu Mar 28 08:07:52 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Concurrency and Computation: Practice and Experience",
  journal-URL =  "http://www.interscience.wiley.com/jpages/1532-0626",
  onlinedate =   "28 February 2018",
}

@Article{Li:2018:PGC,
  author =       "Yue Li and Tian Tan and Anders M{\o}ller and Yannis
                 Smaragdakis",
  title =        "Precision-guided context sensitivity for pointer
                 analysis",
  journal =      j-PACMPL,
  volume =       "2",
  number =       "OOPSLA",
  pages =        "141:1--141:29",
  month =        oct,
  year =         "2018",
  DOI =          "https://doi.org/10.1145/3276511",
  bibdate =      "Sat Aug 8 07:56:30 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/pacmpl.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3276511",
  abstract =     "Context sensitivity is an essential technique for
                 ensuring high precision in Java pointer analyses. It
                 has been observed that applying context sensitivity
                 partially, only on a select subset of the methods, can
                 improve the balance between analysis \ldots{}",
  acknowledgement = ack-nhfb,
  articleno =    "141",
  fjournal =     "Proceedings of the ACM on Programming Languages",
  journal-URL =  "https://pacmpl.acm.org/",
}

@Article{Liu:2018:JIO,
  author =       "Xuanzhe Liu and Meihua Yu and Yun Ma and Gang Huang
                 and Hong Mei and Yunxin Liu",
  title =        "{i-Jacob}: an Internetware-Oriented Approach to
                 Optimizing Computation-Intensive Mobile {Web}
                 Browsing",
  journal =      j-TOIT,
  volume =       "18",
  number =       "2",
  pages =        "14:1--14:??",
  month =        mar,
  year =         "2018",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/3093899",
  ISSN =         "1533-5399 (print), 1557-6051 (electronic)",
  ISSN-L =       "1533-5399",
  bibdate =      "Sat Sep 21 07:34:08 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/toit.bib",
  abstract =     "Web browsing is always a key requirement of Internet
                 users. Current mobile Web apps can contain
                 computation-intensive JavaScript logics and thus affect
                 browsing performance. Learning from our over-decade
                 research and development experiences of the
                 Internetware paradigm, we present the novel and generic
                 i-Jacob approach to improving the performance of mobile
                 Web browsing with effective JavaScript-code offloading.
                 Our approach proposes a programming abstraction to make
                 mobile Web situational and adaptive to contexts, by
                 specifying the computation-intensive and `` offloadable
                 '' code, and develops a platform-independent
                 lightweight runtime spanning the mobile devices and the
                 cloud. We demonstrate the efficiency of i-Jacob with
                 some typical computation-intensive tasks over various
                 combinations of hardware, operating systems, browsers,
                 and network connections. The improvements can reach up
                 to 49$ \times $ speed-up in response time and 90\%
                 saving in energy.",
  acknowledgement = ack-nhfb,
  articleno =    "14",
  fjournal =     "ACM Transactions on Internet Technology (TOIT)",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J780",
}

@Article{Lochbihler:2018:MTS,
  author =       "Andreas Lochbihler",
  title =        "Mechanising a Type-Safe Model of Multithreaded {Java}
                 with a Verified Compiler",
  journal =      j-J-AUTOM-REASON,
  volume =       "61",
  number =       "1--4",
  pages =        "243--332",
  month =        jun,
  year =         "2018",
  CODEN =        "JAREEW",
  DOI =          "https://doi.org/10.1007/s10817-018-9452-x",
  ISSN =         "0168-7433 (print), 1573-0670 (electronic)",
  ISSN-L =       "0168-7433",
  bibdate =      "Sat Aug 4 07:51:41 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/jautomreason.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://link.springer.com/article/10.1007/s10817-018-9452-x",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Automated Reasoning",
  journal-URL =  "http://link.springer.com/journal/10817",
}

@Article{Mace:2018:PTD,
  author =       "Jonathan Mace and Ryan Roelke and Rodrigo Fonseca",
  title =        "Pivot Tracing: Dynamic Causal Monitoring for
                 Distributed Systems",
  journal =      j-TOCS,
  volume =       "35",
  number =       "4",
  pages =        "11:1--11:??",
  month =        dec,
  year =         "2018",
  CODEN =        "ACSYEC",
  DOI =          "https://doi.org/10.1145/3208104",
  ISSN =         "0734-2071 (print), 1557-7333 (electronic)",
  ISSN-L =       "0734-2071",
  bibdate =      "Sat Sep 21 11:44:29 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/tocs.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3208104",
  abstract =     "Monitoring and troubleshooting distributed systems is
                 notoriously difficult; potential problems are complex,
                 varied, and unpredictable. The monitoring and diagnosis
                 tools commonly used today-logs, counters, and
                 metrics-have two important limitations: what gets
                 recorded is defined a priori, and the information is
                 recorded in a component- or machine-centric way, making
                 it extremely hard to correlate events that cross these
                 boundaries. This article presents Pivot Tracing, a
                 monitoring framework for distributed systems that
                 addresses both limitations by combining dynamic
                 instrumentation with a novel relational operator: the
                 happened-before join. Pivot Tracing gives users, at
                 runtime, the ability to define arbitrary metrics at one
                 point of the system, while being able to select,
                 filter, and group by events meaningful at other parts
                 of the system, even when crossing component or machine
                 boundaries. We have implemented a prototype of Pivot
                 Tracing for Java-based systems and evaluate it on a
                 heterogeneous Hadoop cluster comprising HDFS, HBase,
                 MapReduce, and YARN. We show that Pivot Tracing can
                 effectively identify a diverse range of root causes
                 such as software bugs, misconfiguration, and limping
                 hardware. We show that Pivot Tracing is dynamic,
                 extensible, and enables cross-tier analysis between
                 inter-operating applications, with low execution
                 overhead.",
  acknowledgement = ack-nhfb,
  articleno =    "11",
  fjournal =     "ACM Transactions on Computer Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J774",
}

@Book{Morgan:2018:SJW,
  author =       "Joe Morgan",
  title =        "Simplifying {JavaScript}: writing modern {JavaScript}
                 with {ES5}, {ES6}, and beyond",
  publisher =    "The Pragmatic Bookshelf",
  address =      "Raleigh, North Carolina",
  pages =        "xiv + 260",
  year =         "2018",
  ISBN =         "1-68050-288-3 (paperback), 1-68050-604-8",
  ISBN-13 =      "978-1-68050-288-6 (paperback), 978-1-68050-604-4",
  LCCN =         "????",
  bibdate =      "Fri Sep 13 08:27:58 MDT 2019",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "The best modern JavaScript is simple, readable, and
                 predictable. Learn to write modern JavaScript not by
                 memorizing a list of new syntax, but with practical
                 examples of how syntax changes can make code more
                 expressive. Starting from variable declarations that
                 communicate intention clearly, see how modern
                 principles can improve all parts of code. Incorporate
                 ideas with curried functions, array methods, classes,
                 and more to create code that does more with less while
                 yielding fewer bugs. It's time to write JavaScript code
                 that's clean and expressive. Modern JavaScript is
                 simpler and more predictable and readable than ever.
                 Discover how to write better code with clear examples
                 using principles that show how updated syntax can make
                 code better with fewer bugs. Starting from the ground
                 up, learn new syntax (or how to reuse older syntax) to
                 transform code from clunky bug-susceptible scripts to
                 clear and elegant programs that are easy to read and
                 easy to extend. Create a foundation for readable code
                 with simple variable declarations that reduce side
                 effects and subtle bugs. Select collections with clear
                 goals instead of defaulting to objects or arrays. See
                 how to simplify iterations from complex loops to single
                 line array methods. Master techniques for writing
                 flexible and solid code ranging from high-order
                 functions, to reusable classes, to patterns for
                 architecting large applications creating applications
                 that will last while through rounds of refactoring and
                 changing requirements. The best part is there's no need
                 to read this book straight through. Jump around and
                 incorporate new functionality at will. Most
                 importantly, understand not just what the new syntax
                 is, but when and how to use it. Start writing better
                 code from the first page. What You Need: For the best
                 experience, have the latest version of Node installed
                 (at least version 7). You can test most examples in the
                 console of Chrome or other modern web browser. If you'd
                 like to run the tests, you'll also need to install the
                 latest version of Node Package Manager (npm).",
  acknowledgement = ack-nhfb,
  shorttableofcontents = "Signal intention with variable assignment \\
                 Manage data collections with arrays \\
                 Maximize code clarity with special collections \\
                 Write clear conditionals \\
                 Simplify loops \\
                 Clean up parameters and return statements \\
                 Build flexible functions \\
                 Keep interfaces clear with classes \\
                 Access external data \\
                 Gather related files with component architecture",
  subject =      "JavaScript (Computer program language); Web site
                 development; JavaScript (Computer program language);
                 Web site development.",
  tableofcontents = "Introduction \\
                 How To Use This Book \\
                 Whom This Book Is For \\
                 Online Resources \\
                 Acknowledgments \\
                 1. Signal Intention with Variable Assignment \\
                 Tip 1. Signal Unchanging Values with const \\
                 Tip 2. Reduce Scope Conflicts with let and const \\
                 Tip 3. Isolate Information with Block Scoped Variables
                 \\
                 Tip 4. Convert Variables to Readable Strings with
                 Template Literals \\
                 2. Manage Data Collections with Arrays \\
                 Tip 5. Create Flexible Collections with Arrays \\
                 Tip 6. Check Existence in an Array with Includes() \\
                 Tip 7. Mold Arrays with the Spread Operator \\
                 Tip 8. Avoid Push Mutations with the Spread Operator
                 \\
                 Tip 9. Avoid Sort Confusion with the Spread Operator
                 \\
                 3. Maximize Code Clarity with Special Collections \\
                 Tip 10. Use Objects for Static Key-Value Lookups \\
                 Tip 11. Create Objects Without Mutations Using
                 Object.assign() \\
                 Tip 12. Update Information with Object Spread \\
                 Tip 13. Update Key-Value Data Clearly with Maps \\
                 Tip 14. Iterate Over Key-Value Data with Map and the
                 Spread Operator \\
                 Tip 15. Create Maps Without Side Effects \\
                 Tip 16. Keep Unique Values with Set \\
                 4. Write Clear Conditionals \\
                 Tip 17. Shorten Conditionals with Falsy Values \\
                 Tip 18. Check Data Quickly with the Ternary Operator
                 \\
                 Tip 19. Maximize Efficiency with Short Circuiting \\
                 5. Simplify Loops \\
                 Tip 20. Simplify Looping with Arrow Functions \\
                 Tip 21. Write Shorter Loops with Array Methods \\
                 Tip 22. Create Arrays of a Similar Size with map() \\
                 Tip 23. Pull Out Subsets of Data with filter() and
                 find() \\
                 Tip 24. Apply Consistent Actions with forEach() \\
                 Tip 25. Combine Methods with Chaining \\
                 Tip 26. Transform Array Data with reduce() \\
                 Tip 27. Reduce Loop Clutter with for \ldots{} in and
                 for \ldots{} each \\
                 6. Clean Up Parameters and Return Statements \\
                 Tip 28. Create Default Parameters \\
                 Tip 29. Access Object Properties with Destructuring \\
                 Tip 30. Simplify Key-Value Assignment \\
                 Tip 31. Pass a Variable Number of Arguments with the
                 Rest Operator \\
                 7. Build Flexible Functions \\
                 Tip 32. Write Functions for Testability \\
                 Tip 33. Reduce Complexity with Arrow Functions \\
                 Tip 34. Maintain Single Responsibility Parameters with
                 Partially Applied Functions \\
                 Tip 35. Combine Currying and Array Methods for Partial
                 Application \\
                 Tip 36. Prevent Context Confusion with Arrow Functions
                 \\
                 8. Keep Interfaces Clear with Classes \\
                 Tip 37. Build Readable Classes \\
                 Tip 38. Share Methods with Inheritance \\
                 Tip 39. Extend Existing Prototypes with Class \\
                 Tip 40. Simplify Interfaces with get and set \\
                 Tip 41. Create Iterable Properties with Generators \\
                 Tip 42. Resolve Context Problems with Bind() \\
                 9. Access External Data \\
                 Tip 43. Retrieve Data Asynchronously with Promises \\
                 Tip 44. Create Clean Functions with Async/Await \\
                 Tip 45. Make Simple AJAX Calls with Fetch \\
                 Tip 46. Maintain State Over Time with LocalStorage \\
                 10. Gather Related Files with Component Architecture
                 \\
                 Tip 47. Isolate Functionality with Import and Export
                 \\
                 Tip 48. Leverage Community Knowledge with npm",
}

@Article{Nguyen:2018:SCM,
  author =       "Khanh Nguyen and Lu Fang and Christian Navasca and
                 Guoqing Xu and Brian Demsky and Shan Lu",
  title =        "{Skyway}: Connecting Managed Heaps in Distributed Big
                 Data Systems",
  journal =      j-SIGPLAN,
  volume =       "53",
  number =       "2",
  pages =        "56--69",
  month =        feb,
  year =         "2018",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3296957.3173200",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Wed Oct 16 14:12:56 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Managed languages such as Java and Scala are
                 prevalently used in development of large-scale
                 distributed systems. Under the managed runtime, when
                 performing data transfer across machines, a task
                 frequently conducted in a Big Data system, the system
                 needs to serialize a sea of objects into a byte
                 sequence before sending them over the network. The
                 remote node receiving the bytes then deserializes them
                 back into objects. This process is both
                 performance-inefficient and labor-intensive: (1) object
                 serialization/deserialization makes heavy use of
                 reflection, an expensive runtime operation and/or (2)
                 serialization/deserialization functions need to be
                 hand-written and are error-prone. This paper presents
                 Skyway, a JVM-based technique that can directly connect
                 managed heaps of different (local or remote) JVM
                 processes. Under Skyway, objects in the source heap can
                 be directly written into a remote heap without changing
                 their formats. Skyway provides performance benefits to
                 any JVM-based system by completely eliminating the need
                 (1) of invoking serialization/deserialization
                 functions, thus saving CPU time, and (2) of requiring
                 developers to hand-write serialization functions.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "ASPLOS '18 proceedings.",
}

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

@Article{Nowicki:2018:MPI,
  author =       "Marek Nowicki and Davit Bzhalava and Piotr Ba{\l}a",
  title =        "Massively Parallel Implementation of Sequence
                 Alignment with Basic Local Alignment Search Tool Using
                 Parallel Computing in {Java} Library",
  journal =      j-J-COMPUT-BIOL,
  volume =       "25",
  number =       "8",
  pages =        "871--881",
  month =        aug,
  year =         "2018",
  CODEN =        "JCOBEM",
  DOI =          "https://doi.org/10.1089/cmb.2018.0079",
  ISSN =         "1066-5277 (print), 1557-8666 (electronic)",
  ISSN-L =       "1066-5277",
  bibdate =      "Sat Jun 1 09:53:28 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/jcomputbiol.bib",
  URL =          "https://www.liebertpub.com/doi/abs/10.1089/cmb.2018.0079;
                 https://www.liebertpub.com/doi/pdf/10.1089/cmb.2018.0079",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Computational Biology",
  journal-URL =  "https://www.liebertpub.com/loi/cmb/",
  onlinedate =   "13 July 2018",
}

@Article{Obaidellah:2018:SUE,
  author =       "Unaizah Obaidellah and Mohammed {Al Haek} and Peter
                 C.-H. Cheng",
  title =        "A Survey on the Usage of Eye-Tracking in Computer
                 Programming",
  journal =      j-COMP-SURV,
  volume =       "51",
  number =       "1",
  pages =        "5:1--5:??",
  month =        apr,
  year =         "2018",
  CODEN =        "CMSVAN",
  DOI =          "https://doi.org/10.1145/3145904",
  ISSN =         "0360-0300 (print), 1557-7341 (electronic)",
  ISSN-L =       "0360-0300",
  bibdate =      "Sat Aug 31 09:04:34 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/compsurv.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  abstract =     "Traditional quantitative research methods of data
                 collection in programming, such as questionnaires and
                 interviews, are the most common approaches for
                 researchers in this field. However, in recent years,
                 eye-tracking has been on the rise as a new method of
                 collecting evidence of visual attention and the
                 cognitive process of programmers. Eye-tracking has been
                 used by researchers in the field of programming to
                 analyze and understand a variety of tasks such as
                 comprehension and debugging. In this article, we will
                 focus on reporting how experiments that used
                 eye-trackers in programming research are conducted, and
                 the information that can be collected from these
                 experiments. In this mapping study, we identify and
                 report on 63 studies, published between 1990 and June
                 2017, collected and gathered via manual search on
                 digital libraries and databases related to computer
                 science and computer engineering. Among the five main
                 areas of research interest are program comprehension
                 and debugging, which received an increased interest in
                 recent years, non-code comprehension, collaborative
                 programming, and requirements traceability research,
                 which had the fewest number of publications due to
                 possible limitations of the eye-tracking technology in
                 this type of experiments. We find that most of the
                 participants in these studies were students and faculty
                 members from institutions of higher learning, and while
                 they performed programming tasks on a range of
                 programming languages and programming representations,
                 we find Java language and Unified Modeling Language
                 (UML) representation to be the most used materials. We
                 also report on a range of eye-trackers and attention
                 tracking tools that have been utilized, and find Tobii
                 eye-trackers to be the most used devices by
                 researchers.",
  acknowledgement = ack-nhfb,
  articleno =    "5",
  fjournal =     "ACM Computing Surveys",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J204",
}

@Article{Olson:2018:CLM,
  author =       "Matthew Benjamin Olson and Joseph T. Teague and
                 Divyani Rao and Michael R. JANTZ and Kshitij A. Doshi
                 and Prasad A. Kulkarni",
  title =        "Cross-Layer Memory Management to Improve {DRAM} Energy
                 Efficiency",
  journal =      j-TACO,
  volume =       "15",
  number =       "2",
  pages =        "20:1--20:??",
  month =        jun,
  year =         "2018",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/3196886",
  ISSN =         "1544-3566 (print), 1544-3973 (electronic)",
  ISSN-L =       "1544-3566",
  bibdate =      "Tue Jan 8 17:19:59 MST 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/taco.bib",
  abstract =     "Controlling the distribution and usage of memory power
                 is often difficult, because these effects typically
                 depend on activity across multiple layers of the
                 vertical execution stack. To address this challenge, we
                 construct a novel and collaborative framework that
                 employs object placement, cross-layer communication,
                 and page-level management to effectively distribute
                 application objects in the DRAM hardware to achieve
                 desired power/performance goals. This work describes
                 the design and implementation of our framework, which
                 is the first to integrate automatic object profiling
                 and analysis at the application layer with fine-grained
                 management of memory hardware resources in the
                 operating system. We demonstrate the utility of this
                 framework by employing it to control memory power
                 consumption more effectively. First, we design a custom
                 memory-intensive workload to show the potential of this
                 approach to reduce DRAM energy consumption. Next, we
                 develop sampling and profiling-based analyses and
                 modify the code generator in the HotSpot VM to
                 understand object usage patterns and automatically
                 control the placement of hot and cold objects in a
                 partitioned VM heap. This information is communicated
                 to the operating system, which uses it to map the
                 logical application pages to the appropriate DRAM
                 modules according to user-defined provisioning goals.
                 The evaluation shows that our Java VM-based framework
                 achieves our goal of significant DRAM energy savings
                 across a variety of workloads, without any source code
                 modifications or recompilations.",
  acknowledgement = ack-nhfb,
  articleno =    "20",
  fjournal =     "ACM Transactions on Architecture and Code Optimization
                 (TACO)",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J924",
}

@Article{Ottoni:2018:HJP,
  author =       "Guilherme Ottoni",
  title =        "{HHVM JIT}: a profile-guided, region-based compiler
                 for {PHP} and Hack",
  journal =      j-SIGPLAN,
  volume =       "53",
  number =       "4",
  pages =        "151--165",
  month =        apr,
  year =         "2018",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3296979.3192374",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Wed Oct 16 14:12:57 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/python.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Dynamic languages such as PHP, JavaScript, Python, and
                 Ruby have been gaining popularity over the last two
                 decades. A very popular domain for these languages is
                 web development, including server-side development of
                 large-scale websites. As a result, improving the
                 performance of these languages has become more
                 important. Efficiently compiling programs in these
                 languages is challenging, and many popular dynamic
                 languages still lack efficient production-quality
                 implementations. This paper describes the design of the
                 second generation of the HHVM JIT and how it addresses
                 the challenges to efficiently execute PHP and Hack
                 programs. This new design uses profiling to build an
                 aggressive region-based JIT compiler. We discuss the
                 benefits of this approach compared to the more popular
                 method-based and trace-based approaches to compile
                 dynamic languages. Our evaluation running a very large
                 PHP-based code base, the Facebook website, demonstrates
                 the effectiveness of the new JIT design.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "PLDI '18 proceedings.",
}

@Article{Ou:2018:TUC,
  author =       "Peizhao Ou and Brian Demsky",
  title =        "Towards understanding the costs of avoiding
                 out-of-thin-air results",
  journal =      j-PACMPL,
  volume =       "2",
  number =       "OOPSLA",
  pages =        "136:1--136:29",
  month =        oct,
  year =         "2018",
  DOI =          "https://doi.org/10.1145/3276506",
  bibdate =      "Sat Aug 8 07:56:30 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/pacmpl.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3276506",
  abstract =     "Eliminating so-called ``out-of-thin-air'' (OOTA)
                 results is an open problem with many existing
                 programming language memory models including Java, C,
                 and C++. OOTA behaviors are problematic in that they
                 break both formal and informal modular reasoning
                 \ldots{}",
  acknowledgement = ack-nhfb,
  articleno =    "136",
  fjournal =     "Proceedings of the ACM on Programming Languages",
  journal-URL =  "https://pacmpl.acm.org/",
}

@Article{Paletov:2018:ICA,
  author =       "Rumen Paletov and Petar Tsankov and Veselin Raychev
                 and Martin Vechev",
  title =        "Inferring crypto {API} rules from code changes",
  journal =      j-SIGPLAN,
  volume =       "53",
  number =       "4",
  pages =        "450--464",
  month =        apr,
  year =         "2018",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3296979.3192403",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Wed Oct 16 14:12:57 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/cryptography2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Creating and maintaining an up-to-date set of security
                 rules that match misuses of crypto APIs is challenging,
                 as crypto APIs constantly evolve over time with new
                 cryptographic primitives and settings, making existing
                 ones obsolete. To address this challenge, we present a
                 new approach to extract security fixes from thousands
                 of code changes. Our approach consists of: (i)
                 identifying code changes, which often capture security
                 fixes, (ii) an abstraction that filters irrelevant code
                 changes (such as refactorings), and (iii) a clustering
                 analysis that reveals commonalities between semantic
                 code changes and helps in eliciting security rules. We
                 applied our approach to the Java Crypto API and showed
                 that it is effective: (i) our abstraction effectively
                 filters non-semantic code changes (over 99\% of all
                 changes) without removing security fixes, and (ii) over
                 80\% of the code changes are security fixes identifying
                 security rules. Based on our results, we identified 13
                 rules, including new ones not supported by existing
                 security checkers.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "PLDI '18 proceedings.",
}

@Article{Pan:2018:ASJ,
  author =       "Weifeng Pan and Bing Li and Jing Liu and Yutao Ma and
                 Bo Hu",
  title =        "Analyzing the structure of {Java} software systems by
                 weighted {$K$}-core decomposition",
  journal =      j-FUT-GEN-COMP-SYS,
  volume =       "83",
  number =       "??",
  pages =        "431--444",
  month =        jun,
  year =         "2018",
  CODEN =        "FGSEVI",
  ISSN =         "0167-739X (print), 1872-7115 (electronic)",
  ISSN-L =       "0167-739X",
  bibdate =      "Thu Mar 15 17:42:39 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/futgencompsys.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "https://www.sciencedirect.com/science/article/pii/S0167739X17320940",
  acknowledgement = ack-nhfb,
  fjournal =     "Future Generation Computer Systems",
  journal-URL =  "http://www.sciencedirect.com/science/journal/0167739X",
}

@Article{Pano:2018:FAL,
  author =       "Amantia Pano and Daniel Graziotin and Pekka
                 Abrahamsson",
  title =        "Factors and actors leading to the adoption of a
                 {JavaScript} framework",
  journal =      j-EMPIR-SOFTWARE-ENG,
  volume =       "23",
  number =       "6",
  pages =        "3503--3534",
  month =        dec,
  year =         "2018",
  CODEN =        "ESENFW",
  DOI =          "https://doi.org/10.1007/s10664-018-9613-x",
  ISSN =         "1382-3256 (print), 1573-7616 (electronic)",
  ISSN-L =       "1382-3256",
  bibdate =      "Fri Oct 11 07:46:30 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/empir-software-eng.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://link.springer.com/article/10.1007/s10664-018-9613-x",
  acknowledgement = ack-nhfb,
  fjournal =     "Empirical Software Engineering",
  journal-URL =  "http://link.springer.com/journal/10664",
}

@Article{Paquin:2018:AAS,
  author =       "Maria Paquin and Elena Sherman and Amit Jain",
  title =        "Assessing the Adequacy of Synthetic Programs for
                 Learning {SPF's} Configurations",
  journal =      j-SIGSOFT,
  volume =       "43",
  number =       "4",
  pages =        "55--55",
  month =        oct,
  year =         "2018",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/3282517.3282526",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Sat Oct 19 18:11:10 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  abstract =     "Static program analysis is a powerful technique that
                 reasons about a program's behavior without actually
                 executing the program. To balance between the precision
                 and the efficiency of an analyzer, developers often
                 manually tune-up analyzer's parameters for a specific
                 program. However, this task can be tedious and
                 time-consuming. To automate the search for the optimal
                 parameters for a program, researchers employ machine
                 learning (ML) techniques, that from the existing data
                 learn the relationship between the program and the
                 optimal parameters, which it encodes in an ML model.
                 The existing, or training, data set, plays an important
                 role in the correctness of an ML model. In this work we
                 investigate whether automatically generated programs
                 are adequate for training an ML model, which determines
                 SPF's configurations for a given Java method. To do
                 this, we compare the performance of a model trained on
                 real programs with that of a model trained on synthetic
                 programs. Our results indicate that while synthetic
                 programs are inadequate for training a model alone,
                 adding them to the training set of real programs
                 improves the classification power of the resulting
                 model.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Park:2018:SAJ,
  author =       "Changhee Park and Hongki Lee and Sukyoung Ryu",
  title =        "Static analysis of {JavaScript} libraries in a
                 scalable and precise way using loop sensitivity",
  journal =      j-SPE,
  volume =       "48",
  number =       "4",
  pages =        "911--944",
  month =        apr,
  year =         "2018",
  CODEN =        "SPEXBL",
  DOI =          "https://doi.org/10.1002/spe.2552",
  ISSN =         "0038-0644 (print), 1097-024X (electronic)",
  ISSN-L =       "0038-0644",
  bibdate =      "Sat Aug 4 10:20:32 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/spe.bib",
  URL =          "https://onlinelibrary.wiley.com/doi/abs/10.1002/spe.2552",
  acknowledgement = ack-nhfb,
  fjournal =     "Software --- Practice and Experience",
  journal-URL =  "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)1097-024X",
  onlinedate =   "23 October 2017",
}

@Article{Phan:2018:TIG,
  author =       "Quoc-Sang Phan",
  title =        "Test input generation using separation logic",
  journal =      j-SIGSOFT,
  volume =       "43",
  number =       "4",
  pages =        "55--55",
  month =        oct,
  year =         "2018",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/3282517.3302418",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Sat Oct 19 18:11:10 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  abstract =     "Unit testing is the practice of testing individual
                 units of a program, where a unit can be a method or a
                 group of methods. Unit testing is important for
                 software development, and automated test case
                 generation is important for reducing the cost and
                 improving the quality of unit testing. When an input of
                 a un is a dynamically allocated data structure, such as
                 list and tree, it has unbounded domain, and strict
                 requirements over the shape or size. This makes test
                 case generation notoriously hard. In this talk, we
                 present Java StarFinder (JSF), a JPF extension for
                 testing units that manipulate data structures. JSF is a
                 symbolic execution engine that uses separation logic
                 specification to capture the constraints over the
                 input, and performs context-sensitive lazy
                 initialization to construct valid test cases.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Porter:2018:PJE,
  author =       "Michael T. Porter",
  title =        "\pkg{js-emass}: A flexible {JavaScript} implementation
                 of the \pkg{emass} algorithm",
  journal =      j-J-OPEN-SOURCE-SOFT,
  volume =       "3",
  number =       "28",
  pages =        "869:1--869:1",
  month =        aug,
  year =         "2018",
  CODEN =        "????",
  DOI =          "https://doi.org/10.21105/joss.00869",
  ISSN =         "2475-9066",
  ISSN-L =       "2475-9066",
  bibdate =      "Thu Sep 13 08:09:35 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/joss.bib",
  URL =          "http://joss.theoj.org/papers/10.21105/joss.00869",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Open Source Software",
  journal-URL =  "http://joss.theoj.org/;
                 https://github.com/openjournals/joss-papers/",
  onlinedate =   "22 August 2018",
  ORCID-numbers = "Michael T. Porter / 0000-0002-1148-6603",
}

@Article{Raghothaman:2018:UGP,
  author =       "Mukund Raghothaman and Sulekha Kulkarni and Kihong Heo
                 and Mayur Naik",
  title =        "User-guided program reasoning using {Bayesian}
                 inference",
  journal =      j-SIGPLAN,
  volume =       "53",
  number =       "4",
  pages =        "722--735",
  month =        apr,
  year =         "2018",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3296979.3192417",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Wed Oct 16 14:12:57 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Program analyses necessarily make approximations that
                 often lead them to report true alarms interspersed with
                 many false alarms. We propose a new approach to
                 leverage user feedback to guide program analyses
                 towards true alarms and away from false alarms. Our
                 approach associates each alarm with a confidence value
                 by performing Bayesian inference on a probabilistic
                 model derived from the analysis rules. In each
                 iteration, the user inspects the alarm with the highest
                 confidence and labels its ground truth, and the
                 approach recomputes the confidences of the remaining
                 alarms given this feedback. It thereby maximizes the
                 return on the effort by the user in inspecting each
                 alarm. We have implemented our approach in a tool named
                 Bingo for program analyses expressed in Datalog.
                 Experiments with real users and two sophisticated
                 analyses---a static datarace analysis for Java programs
                 and a static taint analysis for Android apps---show
                 significant improvements on a range of metrics,
                 including false alarm rates and number of bugs found.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "PLDI '18 proceedings.",
}

@Article{Ramos:2018:APS,
  author =       "M. Ramos and M. T. Valente and R. Terra",
  title =        "{AngularJS} Performance: A Survey Study",
  journal =      j-IEEE-SOFTWARE,
  volume =       "35",
  number =       "2",
  pages =        "72--79",
  month =        mar # "\slash " # apr,
  year =         "2018",
  CODEN =        "IESOEG",
  DOI =          "https://doi.org/10.1109/MS.2017.265100610",
  ISSN =         "0740-7459 (print), 1937-4194 (electronic)",
  ISSN-L =       "0740-7459",
  bibdate =      "Fri Aug 2 09:25:48 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ieeesoft.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE Software",
  journal-URL =  "http://www.computer.org/portal/web/csdl/magazines/software",
  keywords =     "AngularJS; AngularJS applications; AngularJS
                 performance; Computer applications; Computer
                 architecture; custom components; development
                 experience; Internet; Java; JavaScript framework;
                 Mobile handsets; model-view-controller pattern; Object
                 recognition; Performance evaluation; performance
                 problems; single-page Web apps; software development;
                 Software development management; Software engineering;
                 software engineering; software performance; software
                 performance evaluation; Software reliability; web
                 apps",
}

@Article{Rodchenko:2018:TIE,
  author =       "Andrey Rodchenko and Christos Kotselidis and Andy
                 Nisbet and Antoniu Pop and Mikel Luj{\'a}n",
  title =        "Type Information Elimination from Objects on
                 Architectures with Tagged Pointers Support",
  journal =      j-IEEE-TRANS-COMPUT,
  volume =       "67",
  number =       "1",
  pages =        "130--143",
  month =        jan,
  year =         "2018",
  CODEN =        "ITCOB4",
  DOI =          "https://doi.org/10.1109/TC.2017.2709739",
  ISSN =         "0018-9340 (print), 1557-9956 (electronic)",
  ISSN-L =       "0018-9340",
  bibdate =      "Thu Dec 14 07:11:27 2017",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ieeetranscomput2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://ieeexplore.ieee.org/document/7962268/",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE Transactions on Computers",
  journal-URL =  "http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=12",
  keywords =     "Hardware; high-level language architectures; Java;
                 Layout; Memory management; Metadata; Object oriented
                 modeling; Runtime environments; simulation",
}

@Article{Roemer:2018:HCU,
  author =       "Jake Roemer and Kaan Gen{\c{c}} and Michael D. Bond",
  title =        "High-coverage, unbounded sound predictive race
                 detection",
  journal =      j-SIGPLAN,
  volume =       "53",
  number =       "4",
  pages =        "374--389",
  month =        apr,
  year =         "2018",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3296979.3192385",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Wed Oct 16 14:12:57 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Dynamic program analysis can predict data races
                 knowable from an observed execution, but existing
                 predictive analyses either miss races or cannot analyze
                 full program executions. This paper presents
                 Vindicator, a novel, sound (no false races) predictive
                 approach that finds more data races than existing
                 predictive approaches. Vindicator achieves high
                 coverage by using a new, efficient analysis that finds
                 all possible predictable races but may detect false
                 races. Vindicator ensures soundness using a novel
                 algorithm that checks each potential race to determine
                 whether it is a true predictable race. An evaluation
                 using large Java programs shows that Vindicator finds
                 hard-to-detect predictable races that existing sound
                 predictive analyses miss, at a comparable performance
                 cost.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "PLDI '18 proceedings.",
}

@Article{Saini:2018:CNC,
  author =       "Vaibhav Saini and Hitesh Sajnani and Cristina Lopes",
  title =        "Cloned and non-cloned {Java} methods: a comparative
                 study",
  journal =      j-EMPIR-SOFTWARE-ENG,
  volume =       "23",
  number =       "4",
  pages =        "2232--2278",
  month =        aug,
  year =         "2018",
  CODEN =        "ESENFW",
  DOI =          "https://doi.org/10.1007/s10664-017-9572-7",
  ISSN =         "1382-3256 (print), 1573-7616 (electronic)",
  ISSN-L =       "1382-3256",
  bibdate =      "Wed Sep 26 14:34:26 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/empir-software-eng.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://link.springer.com/article/10.1007/s10664-017-9572-7",
  acknowledgement = ack-nhfb,
  fjournal =     "Empirical Software Engineering",
  journal-URL =  "http://link.springer.com/journal/10664",
}

@Article{Santos:2018:JJV,
  author =       "Jos{\'e} Fragoso Santos and Petar Maksimovi{\'c} and
                 Daiva Naud{\v{z}}i{\=u}nien{\.e} and Thomas Wood and
                 Philippa Gardner",
  title =        "{JaVerT}: {JavaScript} verification toolchain",
  journal =      j-PACMPL,
  volume =       "2",
  number =       "POPL",
  pages =        "50:1--50:??",
  month =        jan,
  year =         "2018",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/3158138",
  ISSN =         "2475-1421",
  bibdate =      "Wed Jan 10 09:45:26 MST 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/pacmpl.bib",
  acknowledgement = ack-nhfb,
  articleno =    "50",
  fjournal =     "Proceedings of the ACM on Programming Languages",
  journal-URL =  "https://pacmpl.acm.org/",
}

@Article{Sawant:2018:RDC,
  author =       "Anand Ashok Sawant and Romain Robbes and Alberto
                 Bacchelli",
  title =        "On the reaction to deprecation of clients of $ 4 + 1 $
                 popular {Java APIs} and the {JDK}",
  journal =      j-EMPIR-SOFTWARE-ENG,
  volume =       "23",
  number =       "4",
  pages =        "2158--2197",
  month =        aug,
  year =         "2018",
  CODEN =        "ESENFW",
  DOI =          "https://doi.org/10.1007/s10664-017-9554-9",
  ISSN =         "1382-3256 (print), 1573-7616 (electronic)",
  ISSN-L =       "1382-3256",
  bibdate =      "Wed Sep 26 14:34:26 MDT 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/empir-software-eng.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://link.springer.com/article/10.1007/s10664-017-9554-9;
                 http://link.springer.com/content/pdf/10.1007/s10664-017-9554-9.pdf",
  acknowledgement = ack-nhfb,
  fjournal =     "Empirical Software Engineering",
  journal-URL =  "http://link.springer.com/journal/10664",
}

@Article{Sayed:2018:ITI,
  author =       "Bassam Sayed and Issa Traor{\'e} and Amany
                 Abdelhalim",
  title =        "{If-transpiler}: Inlining of hybrid flow-sensitive
                 security monitor for {JavaScript}",
  journal =      j-COMPUT-SECUR,
  volume =       "75",
  number =       "??",
  pages =        "92--117",
  month =        jun,
  year =         "2018",
  CODEN =        "CPSEDU",
  ISSN =         "0167-4048 (print), 1872-6208 (electronic)",
  ISSN-L =       "0167-4048",
  bibdate =      "Mon Sep 23 09:46:54 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/computsecur2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "https://www.sciencedirect.com/science/article/pii/S0167404818300397",
  acknowledgement = ack-nhfb,
  fjournal =     "Computers \& Security",
  journal-URL =  "https://www.sciencedirect.com/science/journal/01674048",
}

@Article{Selakovic:2018:TGH,
  author =       "Marija Selakovic and Michael Pradel and Rezwana Karim
                 and Frank Tip",
  title =        "Test generation for higher-order functions in dynamic
                 languages",
  journal =      j-PACMPL,
  volume =       "2",
  number =       "OOPSLA",
  pages =        "161:1--161:27",
  month =        oct,
  year =         "2018",
  DOI =          "https://doi.org/10.1145/3276531",
  bibdate =      "Sat Aug 8 07:56:30 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/pacmpl.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3276531",
  abstract =     "Test generation has proven to provide an effective way
                 of identifying programming errors. Unfortunately,
                 current test generation techniques are challenged by
                 higher-order functions in dynamic languages, such as
                 JavaScript functions that receive \ldots{}",
  acknowledgement = ack-nhfb,
  articleno =    "161",
  fjournal =     "Proceedings of the ACM on Programming Languages",
  journal-URL =  "https://pacmpl.acm.org/",
}

@Article{Serrano:2018:JAC,
  author =       "Manuel Serrano",
  title =        "{JavaScript AOT} compilation",
  journal =      j-SIGPLAN,
  volume =       "53",
  number =       "8",
  pages =        "50--63",
  month =        oct,
  year =         "2018",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3393673.3276950",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Wed Apr 8 13:49:51 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3393673.3276950",
  abstract =     "Static compilation, a.k.a., ahead-of-time (AOT)
                 compilation, is an alternative approach to JIT
                 compilation that can combine good speed and lightweight
                 memory footprint, and that can accommodate read-only
                 memory constraints that are imposed by some devices and
                 some operating systems. Unfortunately the highly
                 dynamic nature of JavaScript makes it hard to compile
                 statically and all existing AOT compilers have either
                 gave up on good performance or full language support.
                 We have designed and implemented an AOT compiler that
                 aims at satisfying both. It supports full unrestricted
                 ECMAScript 5.1 plus many ECMAScript 2017 features and
                 the majority of benchmarks are within 50\% of the
                 performance of one of the fastest JIT compilers.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "https://dl.acm.org/loi/sigplan",
}

@Article{Steindorfer:2018:MOA,
  author =       "Michael J. Steindorfer and Jurgen J. Vinju",
  title =        "To-many or to-one? {All}-in-one! {Efficient} purely
                 functional multi-maps with type-heterogeneous
                 hash-tries",
  journal =      j-SIGPLAN,
  volume =       "53",
  number =       "4",
  pages =        "283--295",
  month =        apr,
  year =         "2018",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3296979.3192420",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Wed Oct 16 14:12:57 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/hash.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "An immutable multi-map is a many-to-many map data
                 structure with expected fast insert and lookup
                 operations. This data structure is used for
                 applications processing graphs or many-to-many
                 relations as applied in compilers, runtimes of
                 programming languages, or in static analysis of
                 object-oriented systems. Collection data structures are
                 assumed to carefully balance execution time of
                 operations with memory consumption characteristics and
                 need to scale gracefully from a few elements to
                 multiple gigabytes at least. When processing larger
                 in-memory data sets the overhead of the data structure
                 encoding itself becomes a memory usage bottleneck,
                 dominating the overall performance. In this paper we
                 propose AXIOM, a novel hash-trie data structure that
                 allows for a highly efficient and type-safe multi-map
                 encoding by distinguishing inlined values of singleton
                 sets from nested sets of multi-mappings. AXIOM strictly
                 generalizes over previous hash-trie data structures by
                 supporting the processing of fine-grained
                 type-heterogeneous content on the implementation level
                 (while API and language support for type-heterogeneity
                 are not scope of this paper). We detail the design and
                 optimizations of AXIOM and further compare it against
                 state-of-the-art immutable maps and multi-maps in Java,
                 Scala and Clojure. We isolate key differences using
                 microbenchmarks and validate the resulting conclusions
                 on a case study in static analysis. AXIOM reduces the
                 key-value storage overhead by 1.87x; with specializing
                 and inlining across collection boundaries it improves
                 by 5.1x.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "PLDI '18 proceedings.",
}

@Article{Sun:2018:RAR,
  author =       "Yu-Shan Sun",
  title =        "Reasoning About Reference Behavior with {RESOLVE}",
  journal =      j-SIGSOFT,
  volume =       "43",
  number =       "3",
  pages =        "18--19",
  month =        jul,
  year =         "2018",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/3229783.3229800",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Sat Oct 19 18:11:10 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  abstract =     "As an alternative to reasoning about references
                 explicitly and ACM SIGSOFT Software Engineering Notes
                 Page 18 July 2018 Volume 43 Number 3 routinely as
                 needed for Java-like programs, this paper summarizes
                 the RESOLVE approach in reasoning via reference-hiding
                 data abstractions for the majority of programs and only
                 reasoning about references when they are unavoidable.
                 Furthermore, this paper raises discussion topics for
                 reasoning about various implementation classifications
                 and to explore when there is a need to be concerned
                 about establishing the frame property",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Tanyalcin:2018:LVL,
  author =       "Ibrahim Tanyalcin and Carla {Al Assaf} and Julien
                 Ferte and Fran{\c{c}}ois Ancien and Taushif Khan and
                 Guillaume Smits and Marianne Rooman and Wim Vranken",
  title =        "Lexicon Visualization Library and {JavaScript} for
                 Scientific Data Visualization",
  journal =      j-COMPUT-SCI-ENG,
  volume =       "20",
  number =       "1",
  pages =        "50--65",
  month =        "????",
  year =         "2018",
  CODEN =        "CSENFA",
  DOI =          "https://doi.org/10.1109/MCSE.2018.011111125",
  ISSN =         "1521-9615 (print), 1558-366X (electronic)",
  ISSN-L =       "1521-9615",
  bibdate =      "Thu Feb 15 06:20:46 MST 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/computscieng.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://ieeexplore.ieee.org/document/8291800/",
  acknowledgement = ack-nhfb,
  journal-URL =  "http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=5992",
}

@Article{Tran-Jorgensen:2018:ATV,
  author =       "Peter W. V. Tran-J{\o}rgensen and Peter Gorm Larsen
                 and Gary T. Leavens",
  title =        "Automated translation of {VDM} to {JML}-annotated
                 {Java}",
  journal =      j-INT-J-SOFTW-TOOLS-TECHNOL-TRANSFER,
  volume =       "20",
  number =       "2",
  pages =        "211--235",
  month =        apr,
  year =         "2018",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1007/s10009-017-0448-3",
  ISSN =         "1433-2779 (print), 1433-2787 (electronic)",
  ISSN-L =       "1433-2779",
  bibdate =      "Sat Jan 19 15:00:13 MST 2019",
  bibsource =    "http://link.springer.com/journal/10009/20/2;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sttt.bib",
  URL =          "https://link.springer.com/article/10.1007/s10009-017-0448-3",
  acknowledgement = ack-nhfb,
  fjournal =     "International Journal on Software Tools for Technology
                 Transfer (STTT)",
  journal-URL =  "http://link.springer.com/journal/10009",
}

@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,
  articleno =    "15",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Uva:2018:AWJ,
  author =       "Marcelo Uva and Pablo Ponzio and Germ{\'a}n Regis and
                 Nazareno Aguirre and Marcelo F. Frias",
  title =        "Automated workarounds from {Java} program
                 specifications based on {SAT} solving",
  journal =      j-INT-J-SOFTW-TOOLS-TECHNOL-TRANSFER,
  volume =       "20",
  number =       "6",
  pages =        "665--688",
  month =        nov,
  year =         "2018",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1007/s10009-018-0503-8",
  ISSN =         "1433-2779 (print), 1433-2787 (electronic)",
  ISSN-L =       "1433-2779",
  bibdate =      "Sat Jan 19 15:00:15 MST 2019",
  bibsource =    "http://link.springer.com/journal/10009/20/6;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sttt.bib",
  URL =          "https://link.springer.com/article/10.1007/s10009-018-0503-8",
  acknowledgement = ack-nhfb,
  fjournal =     "International Journal on Software Tools for Technology
                 Transfer (STTT)",
  journal-URL =  "http://link.springer.com/journal/10009",
}

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

@Article{Vilk:2018:BAD,
  author =       "John Vilk and Emery D. Berger",
  title =        "{BLeak}: automatically debugging memory leaks in web
                 applications",
  journal =      j-SIGPLAN,
  volume =       "53",
  number =       "4",
  pages =        "15--29",
  month =        apr,
  year =         "2018",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3296979.3192376",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Wed Oct 16 14:12:57 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Despite the presence of garbage collection in managed
                 languages like JavaScript, memory leaks remain a
                 serious problem. In the context of web applications,
                 these leaks are especially pervasive and difficult to
                 debug. Web application memory leaks can take many
                 forms, including failing to dispose of unneeded event
                 listeners, repeatedly injecting iframes and CSS files,
                 and failing to call cleanup routines in third-party
                 libraries. Leaks degrade responsiveness by increasing
                 GC frequency and overhead, and can even lead to browser
                 tab crashes by exhausting available memory. Because
                 previous leak detection approaches designed for
                 conventional C, C++ or Java applications are
                 ineffective in the browser environment, tracking down
                 leaks currently requires intensive manual effort by web
                 developers. This paper introduces BLeak (Browser Leak
                 debugger), the first system for automatically debugging
                 memory leaks in web applications. BLeak's algorithms
                 leverage the observation that in modern web
                 applications, users often repeatedly return to the same
                 (approximate) visual state (e.g., the inbox view in
                 Gmail). Sustained growth between round trips is a
                 strong indicator of a memory leak. To use BLeak, a
                 developer writes a short script (17-73 LOC on our
                 benchmarks) to drive a web application in round trips
                 to the same visual state. BLeak then automatically
                 generates a list of leaks found along with their root
                 causes, ranked by return on investment. Guided by
                 BLeak, we identify and fix over 50 memory leaks in
                 popular libraries and apps including Airbnb, AngularJS,
                 Google Analytics, Google Maps SDK, and jQuery. BLeak's
                 median precision is 100\%; fixing the leaks it
                 identifies reduces heap growth by an average of 94\%,
                 saving from 0.5 MB to 8 MB per round trip. We believe
                 BLeak's approach to be broadly applicable beyond web
                 applications, including to GUI applications on desktop
                 and mobile platforms.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "PLDI '18 proceedings.",
}

@Article{Wang:2018:HSA,
  author =       "Kunshan Wang and Stephen M. Blackburn and Antony L.
                 Hosking and Michael Norrish",
  title =        "Hop, Skip, \& Jump: Practical On-Stack Replacement for
                 a Cross-Platform Language-Neutral {VM}",
  journal =      j-SIGPLAN,
  volume =       "53",
  number =       "3",
  pages =        "1--16",
  month =        mar,
  year =         "2018",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3296975.3186412",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Wed Oct 16 14:12:57 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  abstract =     "On-stack replacement (OSR) is a performance-critical
                 technology for many languages, especially dynamic
                 languages. Conventional wisdom, apparent in JavaScript
                 engines such as V8 and SpiderMonkey, is that OSR must
                 be implemented in a low-level (i.e., in assembly) and
                 language-specific way. This paper presents an OSR
                 abstraction based on Swapstack, materialized as the API
                 for a low-level virtual machine, and shows how the
                 abstraction of resumption protocols facilitates an
                 elegant implementation of this API on real hardware.
                 Using an experimental JavaScript implementation, we
                 demonstrate that this API enables the language
                 implementation to perform OSR without the need to deal
                 with machine-level details. We also show that the API
                 itself is implementable on concrete hardware. This work
                 helps crystallize OSR abstractions and, by providing a
                 reusable implementation, brings OSR within reach for
                 more language implementers.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "VEE '18 proceedings.",
}

@Article{Wang:2018:IDG,
  author =       "Wenwen Wang and Jiacheng Wu and Xiaoli Gong and Tao Li
                 and Pen-Chung Yew",
  title =        "Improving Dynamically-Generated Code Performance on
                 Dynamic Binary Translators",
  journal =      j-SIGPLAN,
  volume =       "53",
  number =       "3",
  pages =        "17--30",
  month =        mar,
  year =         "2018",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3296975.3186413",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Wed Oct 16 14:12:57 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "The recent transition in the software industry toward
                 dynamically generated code poses a new challenge to
                 existing dynamic binary translation (DBT) systems. A
                 significant re-translation overhead could be introduced
                 due to the maintenance of the consistency between the
                 dynamically-generated guest code and the corresponding
                 translated host code. To address this issue, this paper
                 presents a novel approach to optimize DBT systems for
                 guest applications with dynamically-generated code. The
                 proposed approach can maximize the reuse of previously
                 translated host code to mitigate the re-translation
                 overhead. A prototype based on such an approach has
                 been implemented on an existing DBT system HQEMU.
                 Experimental results on a set of JavaScript
                 applications show that it can achieve a 1.24X
                 performance speedup on average compared to the original
                 HQEMU.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "VEE '18 proceedings.",
}

@Article{Wang:2018:PBJ,
  author =       "Kaiyuan Wang and Hayes Converse and Milos Gligoric and
                 Sasa Misailovic and Sarfraz Khurshid",
  title =        "A Progress Bar for the {JPF} Search Using Program
                 Executions",
  journal =      j-SIGSOFT,
  volume =       "43",
  number =       "4",
  pages =        "55--55",
  month =        oct,
  year =         "2018",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/3282517.3282525",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Sat Oct 19 18:11:10 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  abstract =     "Software model checkers, such as JPF, are routinely
                 used to explore executions of programs that have very
                 large state spaces. Sometimes the exploration can take
                 a significant amount of time before a bug is found or
                 the checking is complete, in which case the user must
                 patiently wait, possibly for quite some time, to learn
                 the result of checking. A progress bar that accurately
                 shows the status of the search provides the user useful
                 feedback about the time expected for the search to
                 complete. This paper introduces JPFBar, a novel
                 technique to estimate the percentage of work done by
                 the JPF search by computing weights for the execution
                 paths it explores and summing up the weights. JPFBar is
                 embodied into a listener that prints a progress bar
                 during JPF execution. An experimental evaluation using
                 a variety of Java subjects shows that JPFBar provides
                 accurate information about the search's progress and
                 fares well in comparison with a state-based progress
                 estimator that is part of the standard JPF
                 distribution.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Article{Wilcox:2018:VVH,
  author =       "James R. Wilcox and Cormac Flanagan and Stephen N.
                 Freund",
  title =        "{VerifiedFT}: a verified, high-performance precise
                 dynamic race detector",
  journal =      j-SIGPLAN,
  volume =       "53",
  number =       "1",
  pages =        "354--367",
  month =        jan,
  year =         "2018",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3200691.3178514",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Wed Oct 16 14:12:56 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Dynamic data race detectors are valuable tools for
                 testing and validating concurrent software, but to
                 achieve good performance they are typically implemented
                 using sophisticated concurrent algorithms. Thus, they
                 are ironically prone to the exact same kind of
                 concurrency bugs they are designed to detect. To
                 address these problems, we have developed VerifiedFT, a
                 clean slate redesign of the FastTrack race detector
                 [19]. The VerifiedFT analysis provides the same
                 precision guarantee as FastTrack, but is simpler to
                 implement correctly and efficiently, enabling us to
                 mechanically verify an implementation of its core
                 algorithm using CIVL [27]. Moreover, VerifiedFT
                 provides these correctness guarantees without
                 sacrificing any performance over current
                 state-of-the-art (but complex and unverified) FastTrack
                 implementations for Java.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "PPoPP '18 proceedings.",
}

@Article{Wu:2018:EBJ,
  author =       "Mingyu Wu and Ziming Zhao and Haoyu Li and Heting Li
                 and Haibo Chen and Binyu Zang and Haibing Guan",
  title =        "{Espresso}: Brewing {Java} For More Non-Volatility
                 with Non-volatile Memory",
  journal =      j-SIGPLAN,
  volume =       "53",
  number =       "2",
  pages =        "70--83",
  month =        feb,
  year =         "2018",
  CODEN =        "SINODQ",
  DOI =          "https://doi.org/10.1145/3296957.3173201",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Wed Oct 16 14:12:56 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Fast, byte-addressable non-volatile memory (NVM)
                 embraces both near-DRAM latency and disk-like
                 persistence, which has generated considerable interests
                 to revolutionize system software stack and programming
                 models. However, it is less understood how NVM can be
                 combined with managed runtime like Java virtual machine
                 (JVM) to ease persistence management. This paper
                 proposes Espresso, a holistic extension to Java and its
                 runtime, to enable Java programmers to exploit NVM for
                 persistence management with high performance. Espresso
                 first provides a general persistent heap design called
                 Persistent Java Heap (PJH) to manage persistent data as
                 normal Java objects. The heap is then strengthened with
                 a recoverable mechanism to provide crash consistency
                 for heap metadata. Espresso further provides a new
                 abstraction called Persistent Java Object (PJO) to
                 provide an easy-to-use but safe persistence programming
                 model for programmers to persist application data.
                 Evaluation confirms that Espresso significantly
                 outperforms state-of-art NVM support for Java (i.e.,
                 JPA and PCJ) while being compatible to data structures
                 in existing Java programs.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J706",
  remark =       "ASPLOS '18 proceedings.",
}

@Article{Yu:2018:NFN,
  author =       "Chunjiang Yu and Wentao Wu and Jing Wang and Yuxin Lin
                 and Yang and Jiajia Chen and Fei Zhu and Bairong Shen",
  title =        "{NGS-FC}: a Next-Generation Sequencing Data Format
                 Converter",
  journal =      j-TCBB,
  volume =       "15",
  number =       "5",
  pages =        "1683--1691",
  month =        sep,
  year =         "2018",
  CODEN =        "ITCBCY",
  DOI =          "https://doi.org/10.1109/TCBB.2017.2722442",
  ISSN =         "1545-5963 (print), 1557-9964 (electronic)",
  ISSN-L =       "1545-5963",
  bibdate =      "Thu Nov 8 06:18:46 MST 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/tcbb.bib",
  abstract =     "With the widespread implementation of next-generation
                 sequencing NGS technologies, millions of sequences have
                 been produced. A lot of databases were created to store
                 and organize the high-throughput sequencing data.
                 Numerous analysis software programs and tools have been
                 developed over the past years. Most of them use
                 specific formats for data representation and storage.
                 Data interoperability becomes a crucial challenge and
                 many tools have been developed to convert NGS data from
                 one format to another. However, most of them were
                 developed for specific and limited formats. Here, we
                 present NGS-FC Next-Generation Sequencing Format
                 Converter, which provides a framework to support the
                 conversion between several formats. It supports 14
                 formats now and provides interfaces to enable users to
                 improve the existing converters and add new ones.
                 Moreover, NGS-FC achieved the overall competitive
                 performance in comparison with some existing converters
                 in terms of RAM usage and running time. The software is
                 written in Java and can be executed standalone. The
                 source code and documentation are freely available at
                 http://sysbio.suda.edu.cn/NGS-FC.",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE/ACM Transactions on Computational Biology and
                 Bioinformatics",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J954",
}

@Article{Zakai:2018:FPW,
  author =       "Alon Zakai",
  title =        "Fast Physics on the {Web} Using {C++}, {JavaScript},
                 and {Emscripten}",
  journal =      j-COMPUT-SCI-ENG,
  volume =       "20",
  number =       "1",
  pages =        "11--19",
  month =        "????",
  year =         "2018",
  CODEN =        "CSENFA",
  DOI =          "https://doi.org/10.1109/MCSE.2018.110150345",
  ISSN =         "1521-9615 (print), 1558-366X (electronic)",
  ISSN-L =       "1521-9615",
  bibdate =      "Thu Feb 15 06:20:46 MST 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/computscieng.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://ieeexplore.ieee.org/document/8254329/",
  acknowledgement = ack-nhfb,
  journal-URL =  "http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=5992",
}

@Article{Zheng:2018:ADS,
  author =       "Guolong Zheng and Quang Loc Le and ThanhVu Nguyen and
                 Quoc-Sang Phan",
  title =        "Automatic Data Structure Repair using Separation
                 Logic",
  journal =      j-SIGSOFT,
  volume =       "43",
  number =       "4",
  pages =        "66--66",
  month =        oct,
  year =         "2018",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/3282517.3282528",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Sat Oct 19 18:11:10 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  abstract =     "Software systems are often shipped and deployed with
                 both known and unknown bugs. On-the-fly program
                 repairs, which handle runtime errors and allow programs
                 to continue successfully, can help software
                 reliability, e.g., by dealing with inconsistent or
                 corrupted data without interrupting the running
                 program. We report on our work-in-progress that repairs
                 data structure using separation logic. Our technique,
                 inspired by existing works on specification-based
                 repair, takes as input specification written in a
                 separation logic formula and a concrete data structure
                 that fails that specification, and performs on-the-fly
                 repair to make the data conforms with the
                 specification. The use of separation logic allows us to
                 compactly and precisely represent desired properties of
                 data structures and use existing analyses in separation
                 logic to detect and repair bugs in complex data
                 structures. We have developed a prototype, called
                 STARFIX, to repair invalid Java data structures
                 violating given specifications in separation logic.
                 Preliminary results show that tool can efficiently
                 detect and repair inconsistent data structures
                 including lists and trees.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/citation.cfm?id=J728",
}

@Misc{Adams:2019:URP,
  author =       "Ulf Adams and Stephan T. Lavavej and Alexander Bolz
                 and Vinnie Falco and David Tolnay and Mitchell {Blank,
                 Jr.} and Mara Bos and Caleb Spare and Alexander Iljin",
  title =        "{ulfjack/ryu}: Printf Support",
  howpublished = "Web site",
  day =          "12",
  month =        aug,
  year =         "2019",
  DOI =          "https://doi.org/10.5281/zenodo.3366212",
  bibdate =      "Sun Aug 16 18:37:00 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/fparith.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "https://github.com/ulfjack/ryu/tree/v2.0;
                 https://zenodo.org/record/3366212",
  abstract =     "This project contains C and Java implementation of
                 Ryu, as well as a C implementation of Ryu Printf. Ryu
                 converts a floating point number to its shortest
                 decimal representation, whereas Ryu Printf converts a
                 floating point number according to the printf \%f or
                 \%e format. At the time of this writing, these are the
                 fastest known float-to-string conversion algorithms. We
                 have tested the code on Ubuntu 19.04, MacOS Mojave, and
                 Windows 10.",
  acknowledgement = ack-nhfb,
}

@Article{Allyson:2019:SOI,
  author =       "F. B. Allyson and M. L. Danilo and S. M. Jos{\'e} and
                 B. C. Giovanni",
  title =        "{Sherlock} {$N$}-overlap: Invasive Normalization and
                 Overlap Coefficient for the Similarity Analysis Between
                 Source Code",
  journal =      j-IEEE-TRANS-COMPUT,
  volume =       "68",
  number =       "5",
  pages =        "740--751",
  month =        may,
  year =         "2019",
  CODEN =        "ITCOB4",
  DOI =          "https://doi.org/10.1109/TC.2018.2881449",
  ISSN =         "0018-9340 (print), 1557-9956 (electronic)",
  ISSN-L =       "0018-9340",
  bibdate =      "Thu Jul 11 09:46:20 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ieeetranscomput2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE Transactions on Computers",
  journal-URL =  "http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=12",
  keywords =     "computer aided instruction; computer science
                 education; data preprocessing; educational courses;
                 Indexes; invasive normalization; Java; JPlag; method of
                 conformity; MOSS; normalization; overlap coefficient;
                 Plagiarism; Programming; Sherlock N-overlap; Sherlock
                 performance; SIM; similarity analysis; similarity
                 index; similarity investigation tool; source code
                 (software); source code files; Source code similarity
                 detection; source coding; Syntactics; textual
                 documents; Tools",
}

@Article{Almeida:2019:GPD,
  author =       "Andr{\'e} Lu{\'\i}s Barroso Almeida and Leonardo de
                 Souza Cimino and Jos{\'e} Estev{\~a}o Eug{\^e}nio de
                 Resende and Lucas Henrique Moreira Silva and Samuel
                 Queiroz Souza Rocha and Guilherme Aparecido Gregorio
                 and Gustavo Silva Paiva and Saul Delabrida and Haroldo
                 Gambini Santos and Marco Antonio Moreira de Carvalho
                 and Andre Luiz Lins Aquino and Joubert de Castro Lima",
  title =        "A general-purpose distributed computing {Java}
                 middleware",
  journal =      j-CCPE,
  volume =       "31",
  number =       "7",
  pages =        "e4967:1--e4967:??",
  day =          "10",
  month =        apr,
  year =         "2019",
  CODEN =        "CCPEBO",
  DOI =          "https://doi.org/10.1002/cpe.4967",
  ISSN =         "1532-0626 (print), 1532-0634 (electronic)",
  ISSN-L =       "1532-0626",
  bibdate =      "Thu Mar 28 08:07:56 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Concurrency and Computation: Practice and Experience",
  journal-URL =  "http://www.interscience.wiley.com/jpages/1532-0626",
  onlinedate =   "03 October 2018",
}

@Article{Bender:2019:FJC,
  author =       "John Bender and Jens Palsberg",
  title =        "A formalization of {Java}'s concurrent access modes",
  journal =      j-PACMPL,
  volume =       "3",
  number =       "OOPSLA",
  pages =        "142:1--142:28",
  month =        oct,
  year =         "2019",
  DOI =          "https://doi.org/10.1145/3360568",
  bibdate =      "Fri Aug 7 19:22:30 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/pacmpl.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3360568",
  abstract =     "Java's memory model was recently updated and expanded
                 with new access modes. The accompanying documentation
                 for these access modes is intended to make strong
                 guarantees about program behavior that the Java
                 compiler must enforce, yet the documentation is
                 frequently unclear. This makes the intended program
                 behavior ambiguous, impedes discussion of key design
                 decisions, and makes it impossible to prove general
                 properties about the semantics of the access
                 modes.\par

                 In this paper we present the first formalization of
                 Java's access modes. We have constructed an axiomatic
                 model for all of the modes using the Herd modeling
                 tool. This allows us to give precise answers to
                 questions about the behavior of example programs,
                 called litmus tests. We have validated our model using
                 a large suite of litmus tests from existing research
                 which helps to shed light on the relationship with
                 other memory models. We have also modeled the semantics
                 in Coq and proven several general theorems including a
                 DRF guarantee, which says that if a program is properly
                 synchronized then it will exhibit sequentially
                 consistent behavior. Finally, we use our model to prove
                 that the unusual design choice of a partial order among
                 writes to the same location is unobservable in any
                 program.",
  acknowledgement = ack-nhfb,
  articleno =    "142",
  fjournal =     "Proceedings of the ACM on Programming Languages",
  journal-URL =  "https://pacmpl.acm.org/",
}

@Article{Berglund:2019:MSJ,
  author =       "Lasse Berglund and Cyrille Artho",
  title =        "Method summaries for {JPF}",
  journal =      j-SIGSOFT,
  volume =       "44",
  number =       "4",
  pages =        "16--16",
  month =        dec,
  year =         "2019",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/3364452.33644560",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Mar 24 14:07:40 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3364452.33644560",
  abstract =     "Java Pathfinder (JPF) is a virtual machine executing
                 Java byte-code that is able to perform model checking
                 using backtracking execution. Due to backtracking,
                 parts of a program may be executed multiple times
                 during model checking. Hence, we explore \ldots{}",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/loi/sigsoft",
}

@Article{Candel:2019:DMD,
  author =       "Carlos Javier {Fern{\'a}ndez Candel} and Jes{\'u}s
                 {Garc{\'\i}a Molina} and Francisco Javier {Berm{\'u}dez
                 Ruiz} and Jose Ram{\'o}n {Hoyos Barcel{\'o}} and Diego
                 {Sevilla Ruiz} and Benito Jos{\'e} {Cuesta Viera}",
  title =        "Developing a model-driven reengineering approach for
                 migrating {PL\slash SQL} triggers to {Java}: a
                 practical experience",
  journal =      j-J-SYST-SOFTW,
  volume =       "151",
  number =       "??",
  pages =        "38--64",
  month =        may,
  year =         "2019",
  CODEN =        "JSSODM",
  DOI =          "https://doi.org/10.1016/j.jss.2019.01.068",
  ISSN =         "0164-1212 (print), 1873-1228 (electronic)",
  ISSN-L =       "0164-1212",
  bibdate =      "Tue Mar 12 06:58:51 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/jsystsoftw.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0164121219300214",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Systems and Software",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01641212",
}

@Article{Celik:2019:DIA,
  author =       "Ahmet Celik and Pengyu Nie and Christopher J. Rossbach
                 and Milos Gligoric",
  title =        "Design, implementation, and application of {GPU}-based
                 {Java} bytecode interpreters",
  journal =      j-PACMPL,
  volume =       "3",
  number =       "OOPSLA",
  pages =        "177:1--177:28",
  month =        oct,
  year =         "2019",
  DOI =          "https://doi.org/10.1145/3360603",
  bibdate =      "Fri Aug 7 19:22:30 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/pacmpl.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3360603",
  abstract =     "We present the design and implementation of GVM, the
                 first system for executing Java bytecode entirely on
                 GPUs. GVM is ideal for applications that execute a
                 large number of short-living tasks, which share a
                 significant fraction of their codebase and have similar
                 execution time. GVM uses novel algorithms, scheduling,
                 and data layout techniques to adapt to the massively
                 parallel programming and execution model of GPUs. We
                 apply GVM to generate and execute tests for Java
                 projects. First, we implement a sequence-based test
                 generation on top of GVM and design novel algorithms to
                 avoid redundant test sequences. Second, we use GVM to
                 execute randomly generated test cases. We evaluate GVM
                 by comparing it with two existing Java bytecode
                 interpreters (Oracle JVM and Java Pathfinder), as well
                 as with the Oracle JVM with just-in-time (JIT)
                 compiler, which has been engineered and optimized for
                 over twenty years. Our evaluation shows that
                 sequence-based test generation on GVM outperforms both
                 Java Pathfinder and Oracle JVM interpreter.
                 Additionally, our results show that GVM performs as
                 well as running our parallel sequence-based test
                 generation algorithm using JVM with JIT with many CPU
                 threads. Furthermore, our evaluation on several classes
                 from open-source projects shows that executing randomly
                 generated tests on GVM outperforms sequential execution
                 on JVM interpreter and JVM with JIT.",
  acknowledgement = ack-nhfb,
  articleno =    "177",
  fjournal =     "Proceedings of the ACM on Programming Languages",
  journal-URL =  "https://pacmpl.acm.org/",
}

@Article{Chen:2019:ESL,
  author =       "Boyuan Chen and Zhen Ming (Jack) Jiang",
  title =        "Extracting and studying the
                 Logging--Code-Issue-Introducing changes in {Java}-based
                 large-scale open source software systems",
  journal =      j-EMPIR-SOFTWARE-ENG,
  volume =       "24",
  number =       "4",
  pages =        "2285--2322",
  month =        aug,
  year =         "2019",
  CODEN =        "ESENFW",
  DOI =          "https://doi.org/10.1007/s10664-019-09690-0",
  ISSN =         "1382-3256 (print), 1573-7616 (electronic)",
  ISSN-L =       "1382-3256",
  bibdate =      "Fri Oct 11 07:46:32 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/empir-software-eng.bib;
                 https://www.math.utah.edu/pub/tex/bib/gnu.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://link.springer.com/article/10.1007/s10664-019-09690-0",
  acknowledgement = ack-nhfb,
  fjournal =     "Empirical Software Engineering",
  journal-URL =  "http://link.springer.com/journal/10664",
}

@Article{Chen:2019:SVR,
  author =       "Zhenbang Chen and Hengbiao Yu and Ji Wang and Wei
                 Dong",
  title =        "Symbolic Verification of Regular Properties for {Java}
                 Programs",
  journal =      j-SIGSOFT,
  volume =       "44",
  number =       "4",
  pages =        "17--17",
  month =        dec,
  year =         "2019",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/3364452.33644561",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Mar 24 14:07:40 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3364452.33644561",
  abstract =     "Verifying the regular properties of a program is
                 challenging. In this extended abstract, we report our
                 recent progress of verifying regular properties based
                 on dynamic symbolic execution (DSE). We propose two
                 algorithms for DSE to improve the \ldots{}",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/loi/sigsoft",
}

@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,
  articleno =    "1",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Coppolino:2019:CAE,
  author =       "Luigi Coppolino and Salvatore D'Antonio and Giovanni
                 Mazzeo and Luigi Romano",
  title =        "A comparative analysis of emerging approaches for
                 securing {Java} software with {Intel SGX}",
  journal =      j-FUT-GEN-COMP-SYS,
  volume =       "97",
  number =       "??",
  pages =        "620--633",
  month =        aug,
  year =         "2019",
  CODEN =        "FGSEVI",
  ISSN =         "0167-739X (print), 1872-7115 (electronic)",
  ISSN-L =       "0167-739X",
  bibdate =      "Mon Oct 14 16:09:57 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/futgencompsys.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0167739X18315942",
  acknowledgement = ack-nhfb,
  fjournal =     "Future Generation Computer Systems",
  journal-URL =  "http://www.sciencedirect.com/science/journal/0167739X",
}

@InProceedings{Gabaruk:2019:TJO,
  author =       "J. Gabaruk and D. Logofatu and D. Gro{\ss}kreutz and
                 C. Andersson",
  booktitle =    "{2019 IEEE Global Engineering Education Conference
                 (EDUCON)}",
  title =        "On Teaching {Java} and Object Oriented Programming by
                 Using Children Board Games",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  pages =        "601--606",
  year =         "2019",
  DOI =          "https://doi.org/10.1109/EDUCON.2019.8725264",
  bibdate =      "Thu Apr 8 07:17:08 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  keywords =     "Julia programming language",
}

@Article{Gupta:2019:CSJ,
  author =       "Shashank Gupta and B. B. Gupta and Pooja Chaudhary",
  title =        "A client-server {JavaScript} code rewriting-based
                 framework to detect the {XSS} worms from online social
                 network",
  journal =      j-CCPE,
  volume =       "31",
  number =       "21",
  pages =        "e4646:1--e4646:??",
  day =          "10",
  month =        nov,
  year =         "2019",
  CODEN =        "CCPEBO",
  DOI =          "https://doi.org/10.1002/cpe.4646",
  ISSN =         "1532-0626 (print), 1532-0634 (electronic)",
  ISSN-L =       "1532-0626",
  bibdate =      "Wed Mar 31 07:52:09 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  ajournal =     "Concurr. Comput.",
  fjournal =     "Concurrency and Computation: Practice and Experience",
  journal-URL =  "http://www.interscience.wiley.com/jpages/1532-0626",
  onlinedate =   "31 May 2018",
}

@Article{Hua:2019:EED,
  author =       "Jinru Hua and Yushan Zhang and Yuqun Zhang and Sarfraz
                 Khurshid",
  title =        "{EdSketch}: execution-driven sketching for {Java}",
  journal =      j-INT-J-SOFTW-TOOLS-TECHNOL-TRANSFER,
  volume =       "21",
  number =       "3",
  pages =        "249--265",
  month =        jun,
  year =         "2019",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1007/s10009-019-00512-8",
  ISSN =         "1433-2779 (print), 1433-2787 (electronic)",
  ISSN-L =       "1433-2779",
  bibdate =      "Fri Oct 11 15:05:00 MDT 2019",
  bibsource =    "http://link.springer.com/journal/10009/21/3;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sttt.bib",
  URL =          "https://link.springer.com/article/10.1007/s10009-019-00512-8",
  acknowledgement = ack-nhfb,
  fjournal =     "International Journal on Software Tools for Technology
                 Transfer (STTT)",
  journal-URL =  "http://link.springer.com/journal/10009",
}

@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/java2010.bib;
                 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,
  articleno =    "3",
  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,
  articleno =    "13",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Ko:2019:WSA,
  author =       "Yoonseok Ko and Xavier Rival and Sukyoung Ryu",
  title =        "Weakly sensitive analysis for {JavaScript}
                 object-manipulating programs",
  journal =      j-SPE,
  volume =       "49",
  number =       "5",
  pages =        "840--884",
  month =        may,
  year =         "2019",
  CODEN =        "SPEXBL",
  DOI =          "https://doi.org/10.1002/spe.2676",
  ISSN =         "0038-0644 (print), 1097-024X (electronic)",
  ISSN-L =       "0038-0644",
  bibdate =      "Sat Oct 12 09:43:46 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/spe.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Software --- Practice and Experience",
  journal-URL =  "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)1097-024X",
  onlinedate =   "07 January 2019",
}

@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,
  articleno =    "6",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Liva:2019:SDE,
  author =       "Giovanni Liva and Muhammad Taimoor Khan and Martin
                 Pinzger",
  title =        "Semantics-driven extraction of timed automata from
                 {Java} programs",
  journal =      j-EMPIR-SOFTWARE-ENG,
  volume =       "24",
  number =       "5",
  pages =        "3114--3150",
  month =        oct,
  year =         "2019",
  CODEN =        "ESENFW",
  DOI =          "https://doi.org/10.1007/s10664-019-09699-5",
  ISSN =         "1382-3256 (print), 1573-7616 (electronic)",
  ISSN-L =       "1382-3256",
  bibdate =      "Fri Oct 11 07:46:32 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/empir-software-eng.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://link.springer.com/article/10.1007/s10664-019-09699-5;
                 http://link.springer.com/content/pdf/10.1007/s10664-019-09699-5.pdf",
  acknowledgement = ack-nhfb,
  fjournal =     "Empirical Software Engineering",
  journal-URL =  "http://link.springer.com/journal/10664",
}

@Article{Lu:2019:PPY,
  author =       "Jingbo Lu and Jingling Xue",
  title =        "Precision-preserving yet fast object-sensitive pointer
                 analysis with partial context sensitivity",
  journal =      j-PACMPL,
  volume =       "3",
  number =       "OOPSLA",
  pages =        "148:1--148:29",
  month =        oct,
  year =         "2019",
  DOI =          "https://doi.org/10.1145/3360574",
  bibdate =      "Fri Aug 7 19:22:30 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/pacmpl.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3360574",
  abstract =     "Object-sensitivity is widely used as a context
                 abstraction for computing the points-to information
                 context-sensitively for object-oriented languages like
                 Java. Due to the combinatorial explosion of contexts in
                 large programs, k -object-sensitive pointer \ldots{}",
  acknowledgement = ack-nhfb,
  articleno =    "148",
  fjournal =     "Proceedings of the ACM on Programming Languages",
  journal-URL =  "https://pacmpl.acm.org/",
}

@Article{Luo:2019:HDS,
  author =       "Q. Luo and K. Moran and L. Zhang and D. Poshyvanyk",
  title =        "How Do Static and Dynamic Test Case Prioritization
                 Techniques Perform on Modern Software Systems? {An}
                 Extensive Study on {GitHub} Projects",
  journal =      j-IEEE-TRANS-SOFTW-ENG,
  volume =       "45",
  number =       "11",
  pages =        "1054--1080",
  month =        nov,
  year =         "2019",
  CODEN =        "IESEDJ",
  DOI =          "https://doi.org/10.1109/TSE.2018.2822270",
  ISSN =         "0098-5589 (print), 1939-3520 (electronic)",
  ISSN-L =       "0098-5589",
  bibdate =      "Thu Dec 12 06:35:49 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/gnu.bib;
                 https://www.math.utah.edu/pub/tex/bib/ieeetranssoftweng2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE Transactions on Software Engineering",
  journal-URL =  "http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=32",
  keywords =     "Computer bugs; dynamic; dynamic TCP techniques;
                 dynamic test case prioritization techniques; Fault
                 detection; fault diagnosis; GitHub projects; Java;
                 Measurement; mutation analysis; program testing;
                 quality metrics; real-word Java programs; regression
                 analysis; Regression testing; regression testing
                 technique; Software systems; software systems; static;
                 static TCP techniques; static techniques; static test
                 case prioritization techniques; TCP effectiveness; test
                 case prioritization; test-class granularity;
                 test-method granularity; Testing",
}

@Article{Maas:2019:HAT,
  author =       "M. Maas and K. Asanovic and J. Kubiatowicz",
  title =        "A Hardware Accelerator for Tracing Garbage
                 Collection",
  journal =      j-IEEE-MICRO,
  volume =       "39",
  number =       "3",
  pages =        "38--46",
  month =        may # "\slash " # jun,
  year =         "2019",
  CODEN =        "IEMIDZ",
  DOI =          "https://doi.org/10.1109/MM.2019.2910509",
  ISSN =         "0272-1732 (print), 1937-4143 (electronic)",
  ISSN-L =       "0272-1732",
  bibdate =      "Thu Jul 25 15:33:44 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ieeemicro.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE Micro",
  journal-URL =  "http://www.computer.org/csdl/mags/mi/index.html",
  keywords =     "end-to-end RTL prototype; field programmable gate
                 arrays; garbage collection; garbage-collected
                 languages; GC accelerator; Hardware; hardware
                 accelerator; in-order CPU; Java; Linux; memory
                 controller; Memory management; Object recognition;
                 pause-free garbage collectors; reduced instruction set
                 computing; Servers; SoC; Software; stop-the-world
                 garbage collector; storage management; System-on-chip;
                 system-on-chip",
}

@Article{Marchetto:2019:CCR,
  author =       "A. Marchetto and G. Scanniello and A. Susi",
  title =        "Combining Code and Requirements Coverage with
                 Execution Cost for Test Suite Reduction",
  journal =      j-IEEE-TRANS-SOFTW-ENG,
  volume =       "45",
  number =       "4",
  pages =        "363--390",
  month =        apr,
  year =         "2019",
  CODEN =        "IESEDJ",
  DOI =          "https://doi.org/10.1109/TSE.2017.2777831",
  ISSN =         "0098-5589 (print), 1939-3520 (electronic)",
  ISSN-L =       "0098-5589",
  bibdate =      "Thu Aug 29 15:46:23 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ieeetranssoftweng2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE Transactions on Software Engineering",
  journal-URL =  "http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=32",
  keywords =     "Business; Java; Large scale integration;
                 Multi-objective approach; MultiObjective test suites
                 REduction; original test suites; program testing;
                 regression analysis; regression testing; Software;
                 Software engineering; software fault tolerance;
                 software maintenance; Space exploration; suite
                 exercise; test cases; test suite reduction; testing;
                 Testing; under-test application",
}

@Article{Mastrangelo:2019:CAD,
  author =       "Luis Mastrangelo and Matthias Hauswirth and Nathaniel
                 Nystrom",
  title =        "Casting about in the dark: an empirical study of cast
                 operations in {Java} programs",
  journal =      j-PACMPL,
  volume =       "3",
  number =       "OOPSLA",
  pages =        "158:1--158:31",
  month =        oct,
  year =         "2019",
  DOI =          "https://doi.org/10.1145/3360584",
  bibdate =      "Fri Aug 7 19:22:30 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/pacmpl.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3360584",
  abstract =     "The main goal of a static type system is to prevent
                 certain kinds of errors from happening at run time. A
                 type system is formulated as a set of constraints that
                 gives any expression or term in a program a
                 well-defined type. Yet mainstream programming languages
                 are endowed with type systems that provide the means to
                 circumvent their constraints through casting.\par

                 We want to understand how and when developers escape
                 the static type system to use dynamic typing. We
                 empirically study how casting is used by developers in
                 more than seven thousand Java projects. We find that
                 casts are widely used (8.7\% of methods contain at
                 least one cast) and that 50\% of casts we inspected are
                 not guarded locally to ensure against potential
                 run-time errors.\par

                 To help us better categorize use cases and thus
                 understand how casts are used in practice, we identify
                 25 cast-usage patterns---recurrent programming idioms
                 using casts to solve a specific issue. This knowledge
                 can be: (a) a recommendation for current and future
                 language designers to make informed decisions (b) a
                 reference for tool builders, e.g., by providing more
                 precise or new refactoring analyses, (c) a guide for
                 researchers to test new language features, or to carry
                 out controlled programming experiments, and (d) a guide
                 for developers for better practices.",
  acknowledgement = ack-nhfb,
  articleno =    "158",
  fjournal =     "Proceedings of the ACM on Programming Languages",
  journal-URL =  "https://pacmpl.acm.org/",
}

@Book{McNerney:2019:BBB,
  author =       "P. J. McNerney",
  title =        "Beginning {Bazel}: Building and Testing for {Java},
                 {Go}, and More",
  publisher =    pub-APRESS,
  address =      pub-APRESS:adr,
  pages =        "xi + 192",
  year =         "2019",
  ISBN =         "1-4842-5194-6",
  ISBN-13 =      "978-1-4842-5193-5, 978-1-4842-5194-2",
  LCCN =         "QA75.5-76.95",
  bibdate =      "Thu Apr 22 10:09:52 MDT 2021",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 https://www.math.utah.edu/pub/tex/bib/go.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://www.vlebooks.com/vleweb/product/openreader?id=none\%26isbn=9781484251942",
  abstract =     "Discover Bazel, a new build and software test set of
                 tools for today's programmers and developers. This book
                 shows you how to speed up your builds and tests, and
                 how to use Bazel in the context of your favorite
                 programming language. You'll see that the languages and
                 SDKs supported include Java, Android, iOS, and Go. What
                 You Will Learn Use Bazel as a build tool Test software
                 with Bazel Work with Java, C++, Android, iOS, Go, and
                 other programming languages Run Bazel on Linux, macOS,
                 and Windows Scale and extend Bazel to other languages
                 and platforms Who This Book Is For Experienced
                 programmers looking for alternative build/test tools.",
  acknowledgement = ack-nhfb,
  remark =       "Referencing Build Targets Outside of the Current
                 Package.",
  subject =      "Computer software; Development; Testing",
  tableofcontents = "About the Author \\
                 About the Technical Reviewer \\
                 1: Introduction \\
                 What This Book Is \\
                 What This Book Is Not \\
                 Features of Bazel \\
                 High-Level Build Language \\
                 Explicit Dependency Management \\
                 Advanced Visibility Features \\
                 Explicit Workspace Management \\
                 Remote Build Execution and Caching \\
                 Build Dependency Analysis \\
                 Fast, Correct Builds (and Tests) \\
                 Who This Book Is For (and Possibly Not For) \\
                 2: Setup and Installation \\
                 MacOS \\
                 Installing Xcode \\
                 Installing Bazel \\
                 Installing Java \\
                 Verifying Your Python Version \\
                 Ubuntu Linux \\
                 Installing Required Packages \\
                 Installing Bazel \\
                 Installing Java \\
                 Windows \\
                 Setting Up Your System \\
                 Installing Required Applications \\
                 Visual C++ Redistributable for Visual Studio 2015 \\
                 MSYS2 \\
                 Bazel Installation \\
                 Installing Language Support \\
                 C++ \\
                 Java \\
                 Python \\
                 Final Word \\
                 3: Your First Bazel Project \\
                 Setting Up Your Workspace \\
                 Adding Source Code \\
                 Hello World, Java Style \\
                 Specifying the BUILD Targets \\
                 Building Your Targets \\
                 Build the Binary \\
                 Running the Binary \\
                 Creating and Using Dependencies \\
                 Adding IntMulitplier.java to java\_binary \\
                 Creating a java\_library Dependency \\
                 Depending on Build Targets \\
                 Testing Your Build Targets \\
                 Setting Up Testing Dependencies \\
                 Creating the java\_test Build Target \\
                 Build (and Clean) the World \\
                 Build Everything (In a Directory) \\
                 Build Everything (At This Directory and Below) \\
                 Clean (Mostly) Everything \\
                 Final Word \\
                 4: WORKSPACE File Functionality \\
                 WORKSPACE Files \\
                 Adding New Rules to WORKSPACE \\
                 A Deeper Dive into the Load Path \\
                 Finding the bazel\_tools Repository \\
                 Loading Multiple Rules at the Same Time \\
                 Referencing Other Dependencies \\
                 http\_archive \\
                 git\_repository \\
                 Retrieving a Git Repository \\
                 Fine Print on git\_repository \\
                 http\_archive vs. git\_repository \\
                 Employing a New Language \\
                 Locating the Go Language Rules Repository \\
                 5: A Simple Echo Client/Server Program \\
                 Setting Up Your Workspace \\
                 Go Echo Server \\
                 Java Echo Client \\
                 Naming the Echo Client and Server \\
                 Echoing Between Programs \\
                 Upgrading to JSON \\
                 JSON in Go \\
                 JSON in Java \\
                 GSON Setup \\
                 Adding the Transmission Object to EchoClient \\
                 Executing the Echo Client/Server with JSONFinal Word:
                 Duplication of Effort \\
                 6: Protocol Buffers and Bazel \\
                 Setting Up Your Workspace \\
                 Creating Your First Protocol Buffer \\
                 Using the Protocol Buffer in Java \\
                 Creating the Java Proto Library Target \\
                 Using Your Java Protocol Buffer Target \\
                 Using the Protocol Buffer in Go \\
                 Creating the Go Proto Library Target \\
                 Using Your Go Protocol Buffer Target \\
                 Echo Using Protocol Buffers \\
                 Dependency Tracking and Management \\
                 Change Management in Action \\
                 Final Word \\
                 7: Code Organization and Bazel \\
                 Setup \\
                 Separating the Protocol Buffers",
}

@Article{Mehrabi:2019:PUP,
  author =       "Mostafa Mehrabi and Nasser Giacaman and Oliver
                 Sinnen",
  title =        "{@PT}: Unobtrusive parallel programming with {Java}
                 annotations",
  journal =      j-CCPE,
  volume =       "31",
  number =       "1",
  pages =        "e4831:1--e4831:??",
  day =          "10",
  month =        jan,
  year =         "2019",
  CODEN =        "CCPEBO",
  DOI =          "https://doi.org/10.1002/cpe.4831",
  ISSN =         "1532-0626 (print), 1532-0634 (electronic)",
  ISSN-L =       "1532-0626",
  bibdate =      "Thu Mar 28 08:07:54 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Concurrency and Computation: Practice and Experience",
  journal-URL =  "http://www.interscience.wiley.com/jpages/1532-0626",
  onlinedate =   "27 July 2018",
}

@Article{Mesbah:2019:REJ,
  author =       "Abdelhak Mesbah and Jean-Louis Lanet and Mohamed
                 Mezghiche",
  title =        "Reverse engineering {Java Card} and vulnerability
                 exploitation: a shortcut to {ROM}",
  journal =      j-INT-J-INFO-SEC,
  volume =       "18",
  number =       "1",
  pages =        "85--100",
  month =        feb,
  year =         "2019",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1007/s10207-018-0401-9",
  ISSN =         "1615-5262 (print), 1615-5270 (electronic)",
  ISSN-L =       "1615-5262",
  bibdate =      "Tue Jan 22 17:04:47 MST 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/intjinfosec.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://link.springer.com/article/10.1007/s10207-018-0401-9",
  acknowledgement = ack-nhfb,
  fjournal =     "International Journal of Information Security",
  journal-URL =  "https://link.springer.com/journal/10207",
}

@Article{Miyazawa:2019:SCS,
  author =       "Alvaro Miyazawa and Ana Cavalcanti and Andy Wellings",
  title =        "{SCJ-Circus}: Specification and refinement of
                 Safety-Critical {Java} programs",
  journal =      j-SCI-COMPUT-PROGRAM,
  volume =       "181",
  number =       "??",
  pages =        "140--176",
  day =          "15",
  month =        jul,
  year =         "2019",
  CODEN =        "SCPGD4",
  ISSN =         "0167-6423 (print), 1872-7964 (electronic)",
  ISSN-L =       "0167-6423",
  bibdate =      "Fri Sep 6 06:29:36 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/scicomputprogram.bib",
  URL =          "https://www.sciencedirect.com/science/article/pii/S0167642319300012",
  acknowledgement = ack-nhfb,
  fjournal =     "Science of Computer Programming",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01676423",
}

@Article{Noller:2019:CSS,
  author =       "Yannic Noller and Hoang Lam Nguyen and Minxing Tang
                 and Timo Kehrer and Lars Grunske",
  title =        "Complete Shadow Symbolic Execution with {Java
                 PathFinder}",
  journal =      j-SIGSOFT,
  volume =       "44",
  number =       "4",
  pages =        "15--16",
  month =        dec,
  year =         "2019",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/3364452.33644558",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Mar 24 14:07:40 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3364452.33644558",
  abstract =     "Regression testing ensures the correctness of the
                 software during its evolution, with special attention
                 on the absence of unintended side-effects that might be
                 introduced by changes. However, the manual creation of
                 regression test cases, which expose \ldots{}",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/loi/sigsoft",
}

@Article{Pan:2019:GCF,
  author =       "Yao Pan and Jules White and Yu Sun and Jeff Gray",
  title =        "Gray Computing: A Framework for Computing with
                 Background {JavaScript} Tasks",
  journal =      j-IEEE-TRANS-SOFTW-ENG,
  volume =       "45",
  number =       "??",
  pages =        "171--193",
  month =        "????",
  year =         "2019",
  CODEN =        "IESEDJ",
  DOI =          "https://doi.org/10.1109/TSE.2017.2772812",
  ISSN =         "0098-5589 (print), 1939-3520 (electronic)",
  ISSN-L =       "0098-5589",
  bibdate =      "Thu Feb 14 06:26:38 MST 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ieeetranssoftweng2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "https://ieeexplore.ieee.org/document/8105894/",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE Transactions on Software Engineering",
  journal-URL =  "http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=32",
}

@Article{Park:2019:ROC,
  author =       "Hyukwoo Park and Sungkook Kim and Jung-Geun Park and
                 Soo-Mook Moon",
  title =        "Reusing the Optimized Code for {JavaScript}
                 Ahead-of-Time Compilation",
  journal =      j-TACO,
  volume =       "15",
  number =       "4",
  pages =        "54:1--54:??",
  month =        jan,
  year =         "2019",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/3291056",
  ISSN =         "1544-3566 (print), 1544-3973 (electronic)",
  ISSN-L =       "1544-3566",
  bibdate =      "Tue Jan 8 17:20:00 MST 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/taco.bib",
  abstract =     "As web pages and web apps increasingly include heavy
                 JavaScript code, JavaScript performance has been a
                 critical issue. Modern JavaScript engines achieve a
                 remarkable performance by employing tiered-execution
                 architecture based on interpreter, baseline
                 just-in-time compiler (JITC), and optimizing JITC.
                 Unfortunately, they suffer from a substantial
                 compilation overhead, which can take more than 50\% of
                 the whole running time. A simple idea to reduce the
                 compilation overhead is ahead-of-time compilation
                 (AOTC), which reuses the code generated in the previous
                 run. In fact, existing studies that reuse the bytecode
                 generated by the interpreter or the machine code
                 generated by the baseline JITC have shown tangible
                 performance benefits [12, 31, 41]. However, there has
                 been no study to reuse the machine code generated by
                 the optimizing JITC, which heavily uses profile-based
                 optimizations, thus not easily reusable. We propose a
                 novel AOTC that can reuse the optimized machine code
                 for high-performance JavaScript engines. Unlike
                 previous AOTCs, we need to resolve a few challenging
                 issues related to reusing profile-based optimized code
                 and relocating dynamic addresses. Our AOTC improves the
                 performance of a commercial JavaScript engine by 6.36
                 times (max) and 1.99 times (average) for Octane
                 benchmarks, by reducing the compilation overhead and by
                 running the optimized code from the first invocation of
                 functions. It also improves the loading time of six web
                 apps by 1.28 times, on average.",
  acknowledgement = ack-nhfb,
  articleno =    "54",
  fjournal =     "ACM Transactions on Architecture and Code Optimization
                 (TACO)",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J924",
}

@Article{Pascarella:2019:CCC,
  author =       "Luca Pascarella and Magiel Bruntink and Alberto
                 Bacchelli",
  title =        "Classifying code comments in {Java} software systems",
  journal =      j-EMPIR-SOFTWARE-ENG,
  volume =       "24",
  number =       "3",
  pages =        "1499--1537",
  month =        jun,
  year =         "2019",
  CODEN =        "ESENFW",
  DOI =          "https://doi.org/10.1007/s10664-019-09694-w",
  ISSN =         "1382-3256 (print), 1573-7616 (electronic)",
  ISSN-L =       "1382-3256",
  bibdate =      "Fri Oct 11 07:46:31 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/empir-software-eng.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://link.springer.com/article/10.1007/s10664-019-09694-w;
                 http://link.springer.com/content/pdf/10.1007/s10664-019-09694-w.pdf",
  acknowledgement = ack-nhfb,
  fjournal =     "Empirical Software Engineering",
  journal-URL =  "http://link.springer.com/journal/10664",
}

@Article{Ponzanelli:2019:AIC,
  author =       "L. Ponzanelli and G. Bavota and A. Mocci and R.
                 Oliveto and M. D. Penta and S. Haiduc and B. Russo and
                 M. Lanza",
  title =        "Automatic Identification and Classification of
                 Software Development Video Tutorial Fragments",
  journal =      j-IEEE-TRANS-SOFTW-ENG,
  volume =       "45",
  number =       "5",
  pages =        "464--488",
  month =        may,
  year =         "2019",
  CODEN =        "IESEDJ",
  DOI =          "https://doi.org/10.1109/TSE.2017.2779479",
  ISSN =         "0098-5589 (print), 1939-3520 (electronic)",
  ISSN-L =       "0098-5589",
  bibdate =      "Thu Aug 29 15:46:23 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ieeetranssoftweng2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE Transactions on Software Engineering",
  journal-URL =  "http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=32",
  keywords =     "Androids; automatic identification; CodeTube; computer
                 aided instruction; data mining; Humanoid robots;
                 Indexes; Internet; Java; meta data; mining unstructured
                 data; pattern classification; query processing;
                 Recommender systems; Software; software development
                 video tutorials; software engineering; Tutorials; video
                 fragment; video signal processing; video tutorials;
                 video tutorials mining; YouTube",
}

@Article{Poslavsky:2019:REJ,
  author =       "Stanislav Poslavsky",
  title =        "{Rings}: an efficient {Java\slash Scala} library for
                 polynomial rings",
  journal =      j-COMP-PHYS-COMM,
  volume =       "235",
  number =       "??",
  pages =        "400--413",
  month =        feb,
  year =         "2019",
  CODEN =        "CPHCBZ",
  DOI =          "https://doi.org/10.1016/j.cpc.2018.09.005",
  ISSN =         "0010-4655 (print), 1879-2944 (electronic)",
  ISSN-L =       "0010-4655",
  bibdate =      "Sat Nov 24 07:45:46 MST 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/compphyscomm2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0010465518303199",
  acknowledgement = ack-nhfb,
  fjournal =     "Computer Physics Communications",
  journal-URL =  "http://www.sciencedirect.com/science/journal/00104655",
}

@Article{Raychev:2019:PPP,
  author =       "Veselin Raychev and Martin Vechev and Andreas Krause",
  title =        "Predicting program properties from `big code'",
  journal =      j-CACM,
  volume =       "62",
  number =       "3",
  pages =        "99--107",
  month =        mar,
  year =         "2019",
  CODEN =        "CACMA2",
  DOI =          "https://doi.org/10.1145/3306204",
  ISSN =         "0001-0782 (print), 1557-7317 (electronic)",
  ISSN-L =       "0001-0782",
  bibdate =      "Mon Mar 4 14:30:18 MST 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/cacm2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "https://cacm.acm.org/magazines/2019/3/234932/fulltext",
  abstract =     "We present a new approach for predicting program
                 properties from large codebases (aka ``Big Code''). Our
                 approach learns a probabilistic model from ``Big Code''
                 and uses this model to predict properties of new,
                 unseen programs. The key idea of our work is to
                 transform the program into a representation that allows
                 us to formulate the problem of inferring program
                 properties as structured prediction in machine
                 learning. This enables us to leverage powerful
                 probabilistic models such as Conditional Random Fields
                 (CRFs) and perform joint prediction of program
                 properties. As an example of our approach, we built a
                 scalable prediction engine called JSNICE for solving
                 two kinds of tasks in the context of JavaScript:
                 predicting (syntactic) names of identifiers and
                 predicting (semantic) type annotations of variables.
                 Experimentally, JSNICE predicts correct names for 63\%
                 of name identifiers and its type annotation predictions
                 are correct in 81\% of cases. Since its public release
                 at http://jsnice.org, JSNice has become a popular
                 system with hundreds of thousands of uses. By
                 formulating the problem of inferring program properties
                 as structured prediction, our work opens up the
                 possibility for a range of new ``Big Code''
                 applications such as de-obfuscators, decompilers,
                 invariant generators, and others.",
  acknowledgement = ack-nhfb,
  fjournal =     "Communications of the ACM",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J79",
}

@Article{Resenes:2019:JJM,
  author =       "Jonas de Abreu Resenes and Willingthon Pavan and
                 Carlos Amaral H{\"o}lbig and Jos{\'e} Maur{\'{\i}}cio
                 Cunha Fernandes and Vakhtang Shelia and Cheryl Porter
                 and Gerrit Hoogenboom",
  title =        "\pkg{jDSSAT}: a {JavaScript} module for {DSSAT-CSM}
                 integration",
  journal =      j-SOFTWAREX,
  volume =       "10",
  number =       "??",
  pages =        "Article 100271",
  month =        jul # "\slash " # dec,
  year =         "2019",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1016/j.softx.2019.100271",
  ISSN =         "2352-7110",
  ISSN-L =       "2352-7110",
  bibdate =      "Fri Apr 9 16:04:36 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/softwarex.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S235271101930158X",
  acknowledgement = ack-nhfb,
  fjournal =     "SoftwareX",
  journal-URL =  "https://www.sciencedirect.com/journal/softwarex/issues",
}

@Article{Roohitavaf:2019:AAF,
  author =       "Mohammad Roohitavaf and Sandeep Kulkarni",
  title =        "Automatic Addition of Fault-Tolerance in Presence of
                 Unchangeable Environment Actions",
  journal =      j-FUTURE-INTERNET,
  volume =       "11",
  number =       "7",
  pages =        "144",
  day =          "04",
  month =        jul,
  year =         "2019",
  CODEN =        "????",
  DOI =          "https://doi.org/10.3390/fi11070144",
  ISSN =         "1999-5903",
  bibdate =      "Thu Nov 21 16:51:06 MST 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/future-internet.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "https://www.mdpi.com/1999-5903/11/7/144",
  abstract =     "We focus on the problem of adding fault-tolerance to
                 an existing concurrent protocol in the presence of
                 unchangeable environment actions. Such unchangeable
                 actions occur in cases where a subset of
                 components/processes cannot be modified since they
                 represent third-party components or are constrained by
                 physical laws. These actions differ from faults in that
                 they are (1) simultaneously collaborative and
                 disruptive, (2) essential for satisfying the
                 specification and (3) possibly non-terminating. Hence,
                 if these actions are modeled as faults while adding
                 fault-tolerance, it causes existing model repair
                 algorithms to declare failure to add fault-tolerance.
                 We present a set of algorithms for adding stabilization
                 and fault-tolerance for programs that run in the
                 presence of environment actions. We prove the
                 soundness, completeness and the complexity of our
                 algorithms. We have implemented all of our algorithms
                 using symbolic techniques in Java. The experimental
                 results of our algorithms for various examples are also
                 provided.",
  acknowledgement = ack-nhfb,
  remark =       "Special Issue Dependable Cyber Physical Systems.",
}

@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",
  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,
  articleno =    "19",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Ryu:2019:TAB,
  author =       "S. Ryu and J. Park and J. Park",
  title =        "Toward Analysis and Bug Finding in {JavaScript} {Web}
                 Applications in the Wild",
  journal =      j-IEEE-SOFTWARE,
  volume =       "36",
  number =       "3",
  pages =        "74--82",
  month =        may # "\slash " # jun,
  year =         "2019",
  CODEN =        "IESOEG",
  DOI =          "https://doi.org/10.1109/MS.2018.110113408",
  ISSN =         "0740-7459 (print), 1937-4194 (electronic)",
  ISSN-L =       "0740-7459",
  bibdate =      "Fri Aug 2 09:25:48 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ieeesoft.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE Software",
  journal-URL =  "http://www.computer.org/portal/web/csdl/magazines/software",
  keywords =     "Browsers; bug finding; Computer applications; Computer
                 bugs; ECMAScript family; Electronic publishing;
                 Internet; Java; JavaScript web applications; logics and
                 meanings of programs; Object recognition; open source
                 analysis frameworks; program analysis; program
                 debugging; public domain software; SAFE; scalable
                 analysis framework; semantics of programming languages;
                 software; software engineering; technical challenges;
                 testing and debugging; theory of computation",
}

@Article{Shen:2019:IRA,
  author =       "Bo Shen and Wei Zhang and Haiyan Zhao and Guangtai
                 Liang and Zhi Jin and Qianxiang Wang",
  title =        "{IntelliMerge}: a refactoring-aware software merging
                 technique",
  journal =      j-PACMPL,
  volume =       "3",
  number =       "OOPSLA",
  pages =        "170:1--170:28",
  month =        oct,
  year =         "2019",
  DOI =          "https://doi.org/10.1145/3360596",
  bibdate =      "Fri Aug 7 19:22:30 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/pacmpl.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3360596",
  abstract =     "In modern software development, developers rely on
                 version control systems like Git to collaborate in the
                 branch-based development workflow. One downside of this
                 workflow is the conflicts occurred when merging
                 contributions from different developers: these
                 conflicts are tedious and error-prone to be correctly
                 resolved, reducing the efficiency of collaboration and
                 introducing potential bugs. The situation becomes even
                 worse, with the popularity of refactorings in software
                 development and evolution, because current merging
                 tools (usually based on the text or tree structures of
                 source code) are unaware of refactorings. In this
                 paper, we present IntelliMerge, a graph-based
                 refactoring-aware merging algorithm for Java programs.
                 We explicitly enhance this algorithm's ability in
                 detecting and resolving refactoring-related conflicts.
                 Through the evaluation on 1,070 merge scenarios from 10
                 popular open-source Java projects, we show that
                 IntelliMerge reduces the number of merge conflicts by
                 58.90\% comparing with GitMerge (the prevalent
                 unstructured merging tool) and 11.84\% comparing with
                 jFSTMerge (the state-of-the-art semi-structured merging
                 tool) without sacrificing the auto-merging precision
                 (88.48\%) and recall (90.22\%). Besides, the evaluation
                 of performance shows that IntelliMerge takes 539
                 milliseconds to process one merge scenario on the
                 median, which indicates its feasibility in real-world
                 applications.",
  acknowledgement = ack-nhfb,
  articleno =    "170",
  fjournal =     "Proceedings of the ACM on Programming Languages",
  journal-URL =  "https://pacmpl.acm.org/",
}

@Article{Simao:2019:GWS,
  author =       "J. Sim{\~a}o and S. Esteves and Andr{\'e} Pires and L.
                 Veiga",
  title =        "{{\em GC-Wise}}: a Self-adaptive approach for
                 memory-performance efficiency in {Java VMs}",
  journal =      j-FUT-GEN-COMP-SYS,
  volume =       "100",
  number =       "??",
  pages =        "674--688",
  month =        nov,
  year =         "2019",
  CODEN =        "FGSEVI",
  DOI =          "https://doi.org/10.1016/j.future.2019.05.027",
  ISSN =         "0167-739X (print), 1872-7115 (electronic)",
  ISSN-L =       "0167-739X",
  bibdate =      "Mon Feb 10 12:55:01 MST 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/futgencompsys.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0167739X18304898",
  acknowledgement = ack-nhfb,
  fjournal =     "Future Generation Computer Systems",
  journal-URL =  "http://www.sciencedirect.com/science/journal/0167739X",
}

@Article{Spadini:2019:MOT,
  author =       "Davide Spadini and Maur{\'{\i}}cio Aniche and Magiel
                 Bruntink and Alberto Bacchelli",
  title =        "{Mock} objects for testing {Java} systems",
  journal =      j-EMPIR-SOFTWARE-ENG,
  volume =       "24",
  number =       "3",
  pages =        "1461--1498",
  month =        jun,
  year =         "2019",
  CODEN =        "ESENFW",
  DOI =          "https://doi.org/10.1007/s10664-018-9663-0",
  ISSN =         "1382-3256 (print), 1573-7616 (electronic)",
  ISSN-L =       "1382-3256",
  bibdate =      "Fri Oct 11 07:46:31 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/empir-software-eng.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "http://link.springer.com/article/10.1007/s10664-018-9663-0;
                 http://link.springer.com/content/pdf/10.1007/s10664-018-9663-0.pdf",
  acknowledgement = ack-nhfb,
  fjournal =     "Empirical Software Engineering",
  journal-URL =  "http://link.springer.com/journal/10664",
}

@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,
  articleno =    "18",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Staples:2019:SAB,
  author =       "J. Staples and C. Endicott and L. Krause and P. Pal
                 and P. Samouelian and R. Schantz and A. Wellman",
  title =        "A Semi-Autonomic Bytecode Repair Framework",
  journal =      j-IEEE-SOFTWARE,
  volume =       "36",
  number =       "2",
  pages =        "97--102",
  month =        mar # "\slash " # apr,
  year =         "2019",
  CODEN =        "IESOEG",
  DOI =          "https://doi.org/10.1109/MS.2018.2886829",
  ISSN =         "0740-7459 (print), 1937-4194 (electronic)",
  ISSN-L =       "0740-7459",
  bibdate =      "Fri Aug 2 09:25:48 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ieeesoft.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE Software",
  journal-URL =  "http://www.computer.org/portal/web/csdl/magazines/software",
  keywords =     "Cryptography; Ecosystems; Java; Java virtual machine
                 languages; Maintenance engineering; SABRE;
                 semiautonomic bytecode repair engine framework;
                 Servers; Software development; Software maintenance",
}

@Article{Stein:2019:SAD,
  author =       "Benno Stein and Benjamin Barslev Nielsen and Bor-Yuh
                 Evan Chang and Anders M{\o}ller",
  title =        "Static analysis with demand-driven value refinement",
  journal =      j-PACMPL,
  volume =       "3",
  number =       "OOPSLA",
  pages =        "140:1--140:29",
  month =        oct,
  year =         "2019",
  DOI =          "https://doi.org/10.1145/3360566",
  bibdate =      "Fri Aug 7 19:22:30 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/pacmpl.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3360566",
  abstract =     "Static analysis tools for JavaScript must strike a
                 delicate balance, achieving the level of precision
                 required by the most complex features of target
                 programs without incurring prohibitively high analysis
                 time. For example, reasoning about dynamic \ldots{}",
  acknowledgement = ack-nhfb,
  articleno =    "140",
  fjournal =     "Proceedings of the ACM on Programming Languages",
  journal-URL =  "https://pacmpl.acm.org/",
}

@Article{Storey:2019:SDP,
  author =       "Kyle Storey and Eric Mercer and Pavel Parizek",
  title =        "A Sound Dynamic Partial Order Reduction Engine for
                 {Java Pathfinder}",
  journal =      j-SIGSOFT,
  volume =       "44",
  number =       "4",
  pages =        "15--15",
  month =        dec,
  year =         "2019",
  CODEN =        "SFENDP",
  DOI =          "https://doi.org/10.1145/3364452.3364457",
  ISSN =         "0163-5948 (print), 1943-5843 (electronic)",
  ISSN-L =       "0163-5948",
  bibdate =      "Wed Mar 24 14:07:40 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/sigsoft2010.bib",
  URL =          "https://dl.acm.org/doi/10.1145/3364452.3364457",
  abstract =     "When model checking a multi-threaded program, it is
                 often necessary to enumerate the possible ordering of
                 concurrent events to evaluate the behavior of the
                 program. However, enumerating every possible order of
                 events quickly leads to state-space \ldots{}",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGSOFT Software Engineering Notes",
  journal-URL =  "https://dl.acm.org/loi/sigsoft",
}

@Article{Sudarsan:2019:BDK,
  author =       "V. Sudarsan and R. Sugumar",
  title =        "Building a distributed {$K$}-Means model for {Weka}
                 using remote method invocation {(RMI)} feature of
                 {Java}",
  journal =      j-CCPE,
  volume =       "31",
  number =       "14",
  pages =        "e5313:1--e5313:??",
  day =          "25",
  month =        jul,
  year =         "2019",
  CODEN =        "CCPEBO",
  DOI =          "https://doi.org/10.1002/cpe.5313",
  ISSN =         "1532-0626 (print), 1532-0634 (electronic)",
  ISSN-L =       "1532-0626",
  bibdate =      "Sat Oct 12 11:00:03 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Concurrency and Computation: Practice and Experience",
  journal-URL =  "http://www.interscience.wiley.com/jpages/1532-0626",
  onlinedate =   "09 May 2019",
}

@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,
  articleno =    "16",
  fjournal =     "ACM Transactions on Programming Languages and
                 Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J783",
}

@Article{Wang:2019:DEJ,
  author =       "Yuchen Wang and Kwok Sun Cheng and Myoungkyu Song and
                 Eli Tilevich",
  title =        "A declarative enhancement of {JavaScript} programs by
                 leveraging the {Java} metadata infrastructure",
  journal =      j-SCI-COMPUT-PROGRAM,
  volume =       "181",
  number =       "??",
  pages =        "27--46",
  day =          "15",
  month =        jul,
  year =         "2019",
  CODEN =        "SCPGD4",
  ISSN =         "0167-6423 (print), 1872-7964 (electronic)",
  ISSN-L =       "0167-6423",
  bibdate =      "Fri Sep 6 06:29:36 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/scicomputprogram.bib",
  URL =          "https://www.sciencedirect.com/science/article/pii/S0167642319300723",
  acknowledgement = ack-nhfb,
  fjournal =     "Science of Computer Programming",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01676423",
}

@Article{Wang:2019:OTA,
  author =       "Qingyang Wang and Shungeng Zhang and Yasuhiko Kanemasa
                 and Calton Pu and Balaji Palanisamy and Lilian Harada
                 and Motoyuki Kawaba",
  title =        "Optimizing {$N$}-Tier Application Scalability in the
                 Cloud: A Study of Soft Resource Allocation",
  journal =      j-TOMPECS,
  volume =       "4",
  number =       "2",
  pages =        "10:1--10:??",
  month =        jun,
  year =         "2019",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/3326120",
  ISSN =         "2376-3639",
  bibdate =      "Sat Sep 21 07:21:17 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/tompecs.bib",
  URL =          "https://dl.acm.org/citation.cfm?id=3326120",
  abstract =     "An effective cloud computing environment requires both
                 good performance and high efficiency of computing
                 resources. Through extensive experiments using a
                 representative n-tier benchmark application (Rice
                 University Bulletin Board System (RUBBoS)), we show
                 that the soft resource allocation (e.g., thread pool
                 size and database connection pool size) in component
                 servers has a significant impact on the overall system
                 performance, especially at high system utilization
                 scenarios. Concretely, the same software resource
                 allocation can be a good setting in one hardware
                 configuration and then becomes an either under- or
                 over-allocation in a slightly different hardware
                 configuration, causing a significant performance drop.
                 We have also observed some interesting phenomena that
                 were caused by the non-trivial dependencies between the
                 soft resources of servers in different tiers. For
                 instance, the thread pool size in an Apache web server
                 can limit the total number of concurrent requests to
                 the downstream servers, which surprisingly decreases
                 the Central Processing Unit (CPU) utilization of the
                 Clustered Java Database Connectivity (C-JDBC)
                 clustering middleware as the workload increases. To
                 provide a globally optimal (or near-optimal) soft
                 resource allocation of each tier in the system, we
                 propose a practical iterative solution approach by
                 combining a soft resource aware queuing network model
                 and the fine-grained measurement data of every
                 component server. Our results show that to truly scale
                 complex distributed systems such as n-tier web
                 applications with expected performance in the cloud, we
                 need to carefully manage soft resource allocation in
                 the system.",
  acknowledgement = ack-nhfb,
  articleno =    "10",
  fjournal =     "ACM Transactions on Modeling and Performance
                 Evaluation of Computing Systems (TOMPECS)",
  journal-URL =  "http://dl.acm.org/pub.cfm?id=J1525",
}

@Article{Wang:2019:TRC,
  author =       "Lulu Wang and Jingyue Li and Bixin Li",
  title =        "Tracking runtime concurrent dependences in {Java}
                 threads using thread control profiling",
  journal =      j-J-SYST-SOFTW,
  volume =       "148",
  number =       "??",
  pages =        "116--131",
  month =        feb,
  year =         "2019",
  CODEN =        "JSSODM",
  DOI =          "https://doi.org/10.1016/j.jss.2018.11.003",
  ISSN =         "0164-1212 (print), 1873-1228 (electronic)",
  ISSN-L =       "0164-1212",
  bibdate =      "Wed Dec 5 10:20:00 MST 2018",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/jsystsoftw.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0164121218302395",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Systems and Software",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01641212",
}

@Article{Watt:2019:WW,
  author =       "Conrad Watt and Andreas Rossberg and Jean
                 Pichon-Pharabod",
  title =        "Weakening {WebAssembly}",
  journal =      j-PACMPL,
  volume =       "3",
  number =       "OOPSLA",
  pages =        "133:1--133:28",
  month =        oct,
  year =         "2019",
  DOI =          "https://doi.org/10.1145/3360559",
  bibdate =      "Fri Aug 7 19:22:30 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/pacmpl.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3360559",
  abstract =     "WebAssembly (Wasm) is a safe, portable virtual
                 instruction set that can be hosted in a wide range of
                 environments, such as a Web browser. It is a low-level
                 language whose instructions are intended to compile
                 directly to bare hardware. While the initial version of
                 Wasm focussed on single-threaded computation, a recent
                 proposal extends it with low-level support for multiple
                 threads and atomic instructions for synchronised access
                 to shared memory. To support the correct compilation of
                 concurrent programs, it is necessary to give a suitable
                 specification of its memory model.\par

                 Wasm's language definition is based on a fully
                 formalised specification that carefully avoids
                 undefined behaviour. We present a substantial extension
                 to this semantics, incorporating a relaxed memory
                 model, along with a few proposed extensions. Wasm's
                 memory model is unique in that its linear address space
                 can be dynamically grown during execution, while all
                 accesses are bounds-checked. This leads to the novel
                 problem of specifying how observations about the size
                 of the memory can propagate between threads. We argue
                 that, considering desirable compilation schemes, we
                 cannot give a sequentially consistent semantics to
                 memory growth.\par

                 We show that our model provides sequential consistency
                 for data-race-free executions (SC-DRF). However,
                 because Wasm is to run on the Web, we must also
                 consider interoperability of its model with that of
                 JavaScript. We show, by counter-example, that
                 JavaScript's memory model is not SC-DRF, in contrast to
                 what is claimed in its specification. We propose two
                 axiomatic conditions that should be added to the
                 JavaScript model to correct this difference.\par

                 We also describe a prototype SMT-based litmus tool
                 which acts as an oracle for our axiomatic model,
                 visualising its behaviours, including memory
                 resizing.",
  acknowledgement = ack-nhfb,
  articleno =    "133",
  fjournal =     "Proceedings of the ACM on Programming Languages",
  journal-URL =  "https://pacmpl.acm.org/",
}

@Article{Wijayarathna:2019:WJC,
  author =       "Chamila Wijayarathna and Nalin Asanka Gamagedara
                 Arachchilage",
  title =        "Why {Johnny} can't develop a secure application? {A}
                 usability analysis of {Java Secure Socket Extension
                 API}",
  journal =      j-COMPUT-SECUR,
  volume =       "80",
  number =       "??",
  pages =        "54--73",
  month =        jan,
  year =         "2019",
  CODEN =        "CPSEDU",
  ISSN =         "0167-4048 (print), 1872-6208 (electronic)",
  ISSN-L =       "0167-4048",
  bibdate =      "Mon Sep 23 09:46:58 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/computsecur2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  URL =          "https://www.sciencedirect.com/science/article/pii/S0167404818304887",
  acknowledgement = ack-nhfb,
  fjournal =     "Computers \& Security",
  journal-URL =  "https://www.sciencedirect.com/science/journal/01674048",
}

@Article{Wimmer:2019:IOS,
  author =       "Christian Wimmer and Codrut Stancu and Peter Hofer and
                 Vojin Jovanovic and Paul W{\"o}gerer and Peter B.
                 Kessler and Oleg Pliss and Thomas W{\"u}rthinger",
  title =        "Initialize once, start fast: application
                 initialization at build time",
  journal =      j-PACMPL,
  volume =       "3",
  number =       "OOPSLA",
  pages =        "184:1--184:29",
  month =        oct,
  year =         "2019",
  DOI =          "https://doi.org/10.1145/3360610",
  bibdate =      "Fri Aug 7 19:22:30 MDT 2020",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/pacmpl.bib",
  URL =          "https://dl.acm.org/doi/abs/10.1145/3360610",
  abstract =     "Arbitrary program extension at run time in
                 language-based VMs, e.g., Java's dynamic class loading,
                 comes at a startup cost: high memory footprint and slow
                 warmup. Cloud computing amplifies the startup overhead.
                 Microservices and serverless cloud \ldots{}",
  acknowledgement = ack-nhfb,
  articleno =    "184",
  fjournal =     "Proceedings of the ACM on Programming Languages",
  journal-URL =  "https://pacmpl.acm.org/",
}

@Article{Xu:2019:EEG,
  author =       "Lijie Xu and Tian Guo and Wensheng Dou and Wei Wang
                 and Jun Wei",
  title =        "An experimental evaluation of garbage collectors on
                 big data applications",
  journal =      j-PROC-VLDB-ENDOWMENT,
  volume =       "12",
  number =       "5",
  pages =        "570--583",
  month =        jan,
  year =         "2019",
  CODEN =        "????",
  DOI =          "https://doi.org/10.14778/3303753.3303762",
  ISSN =         "2150-8097",
  bibdate =      "Wed Feb 27 14:03:31 MST 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/vldbe.bib",
  abstract =     "Popular big data frameworks, ranging from Hadoop
                 MapReduce to Spark, rely on garbage-collected
                 languages, such as Java and Scala. Big data
                 applications are especially sensitive to the
                 effectiveness of garbage collection (i.e., GC), because
                 they usually process a large volume of data objects
                 that lead to heavy GC overhead. Lacking in-depth
                 understanding of GC performance has impeded performance
                 improvement in big data applications. In this paper, we
                 conduct the first comprehensive evaluation on three
                 popular garbage collectors, i.e., Parallel, CMS, and
                 G1, using four representative Spark applications. By
                 thoroughly investigating the correlation between these
                 big data applications' memory usage patterns and the
                 collectors' GC patterns, we obtain many findings about
                 GC inefficiencies. We further propose empirical
                 guidelines for application developers, and insightful
                 optimization strategies for designing big-data-friendly
                 garbage collectors.",
  acknowledgement = ack-nhfb,
  fjournal =     "Proceedings of the VLDB Endowment",
  journal-URL =  "http://portal.acm.org/citation.cfm?id=J1174",
}

@Article{Xue:2019:ASC,
  author =       "Y. Xue and Z. Xu and M. Chandramohan and Y. Liu",
  title =        "Accurate and Scalable Cross-Architecture Cross-{OS}
                 Binary Code Search with Emulation",
  journal =      j-IEEE-TRANS-SOFTW-ENG,
  volume =       "45",
  number =       "11",
  pages =        "1125--1149",
  month =        nov,
  year =         "2019",
  CODEN =        "IESEDJ",
  DOI =          "https://doi.org/10.1109/TSE.2018.2827379",
  ISSN =         "0098-5589 (print), 1939-3520 (electronic)",
  ISSN-L =       "0098-5589",
  bibdate =      "Thu Dec 12 06:35:49 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/gnu.bib;
                 https://www.math.utah.edu/pub/tex/bib/ieeetranssoftweng2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE Transactions on Software Engineering",
  journal-URL =  "http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=32",
  keywords =     "3D-CFG; binary clone detection; binary code clones;
                 Binary code search; Binary codes; binary codes; binary
                 executables; BinGo tool; BinGo-E; CFG structures;
                 Cloning; compilation scenario; cross-architecture
                 cross-OS binary code search; cross-architecture
                 matching; cross-compiler matching; cross-OS matching;
                 emulation; Emulation; Feature extraction; high-level
                 semantic features; intra-compiler matching; Java;
                 program compilers; program diagnostics; public domain
                 software; selective inlining technique; Semantics;
                 similar code search; source code clone detection;
                 structural features; Syntactics; Tools; vulnerability
                 matching",
}

@Article{Yan:2019:ACL,
  author =       "M. Yan and X. Xia and E. Shihab and D. Lo and J. Yin
                 and X. Yang",
  title =        "Automating Change-Level Self-Admitted Technical Debt
                 Determination",
  journal =      j-IEEE-TRANS-SOFTW-ENG,
  volume =       "45",
  number =       "12",
  pages =        "1211--1229",
  month =        dec,
  year =         "2019",
  CODEN =        "IESEDJ",
  DOI =          "https://doi.org/10.1109/TSE.2018.2831232",
  ISSN =         "0098-5589 (print), 1939-3520 (electronic)",
  ISSN-L =       "0098-5589",
  bibdate =      "Thu Dec 12 06:35:49 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/gnu.bib;
                 https://www.math.utah.edu/pub/tex/bib/ieeetranssoftweng2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE Transactions on Software Engineering",
  journal-URL =  "http://ieeexplore.ieee.org/xpl/RecentIssue.jsp?punumber=32",
  keywords =     "change-level determination; Feature extraction;
                 History; Java; Labeling; Measurement; self-admitted
                 technical debt; software change; Software quality;
                 Technical debt",
}

@Article{Yang:2019:MGL,
  author =       "Bing Yang and Kenneth B. Kent and Eric Aubanel and
                 Stephen MacKay and Tobi Agila",
  title =        "A multi-granularity locking scheme for {Java}
                 {PackedObjects} based on a concurrent multiway tree",
  journal =      j-CCPE,
  volume =       "31",
  number =       "11",
  pages =        "e5024:1--e5024:??",
  day =          "10",
  month =        jun,
  year =         "2019",
  CODEN =        "CCPEBO",
  DOI =          "https://doi.org/10.1002/cpe.5024",
  ISSN =         "1532-0626 (print), 1532-0634 (electronic)",
  ISSN-L =       "1532-0626",
  bibdate =      "Sat Oct 12 11:00:02 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Concurrency and Computation: Practice and Experience",
  journal-URL =  "http://www.interscience.wiley.com/jpages/1532-0626",
  onlinedate =   "15 October 2018",
}

@Article{Yim:2019:TFS,
  author =       "Keun Soo Yim and Iliyan Malchev and Andrew Hsieh and
                 Dave Burke",
  title =        "{Treble}: Fast Software Updates by Creating an
                 Equilibrium in an Active Software Ecosystem of Globally
                 Distributed Stakeholders",
  journal =      j-TECS,
  volume =       "18",
  number =       "5s",
  pages =        "104:1--104:??",
  month =        oct,
  year =         "2019",
  CODEN =        "????",
  DOI =          "https://doi.org/10.1145/3358237",
  ISSN =         "1539-9087 (print), 1558-3465 (electronic)",
  ISSN-L =       "1539-9087",
  bibdate =      "Thu Oct 17 18:16:44 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/tecs.bib",
  URL =          "https://dl.acm.org/ft_gateway.cfm?id=3358237",
  abstract =     "This paper presents our experience with Treble, a
                 two-year initiative to build the modular base in
                 Android, a Java-based mobile platform running on the
                 Linux kernel. Our Treble architecture splits the
                 hardware independent core framework written in Java
                 from the hardware dependent vendor implementations
                 (e.g., user space device drivers, vendor native
                 libraries, and kernel written in C/C++). Cross-layer
                 communications between them are done via versioned,
                 stable inter-process communication interfaces whose
                 backward compatibility is tested by using two API
                 compliance suites. Based on this architecture, we
                 repackage the key Android software components that
                 suffered from crucial post-launch security bugs as
                 separate images. That not only enables separate
                 ownerships but also independent updates of each image
                 by interested ecosystem entities. We discuss our
                 experience of delivering Treble architectural changes
                 to silicon vendors and device makers using a yearly
                 release model. Our experiments and industry rollouts
                 support our hypothesis that giving more freedom to all
                 ecosystem entities and creating an equilibrium are a
                 transformation necessary to further scale the world
                 largest open source ecosystem with over two billion
                 active devices.",
  acknowledgement = ack-nhfb,
  articleno =    "104",
  fjournal =     "ACM Transactions on Embedded Computing Systems",
  journal-URL =  "http://portal.acm.org/browse_dl.cfm?idx=J840",
}

@Article{Zeuch:2019:AES,
  author =       "Steffen Zeuch and Bonaventura {Del Monte} and Jeyhun
                 Karimov and Clemens Lutz and Manuel Renz and Jonas
                 Traub and Sebastian Bre{\ss} and Tilmann Rabl and
                 Volker Markl",
  title =        "Analyzing efficient stream processing on modern
                 hardware",
  journal =      j-PROC-VLDB-ENDOWMENT,
  volume =       "12",
  number =       "5",
  pages =        "516--530",
  month =        jan,
  year =         "2019",
  CODEN =        "????",
  DOI =          "https://doi.org/10.14778/3303753.3303758",
  ISSN =         "2150-8097",
  bibdate =      "Wed Feb 27 14:03:31 MST 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/virtual-machines.bib;
                 https://www.math.utah.edu/pub/tex/bib/vldbe.bib",
  abstract =     "Modern Stream Processing Engines (SPEs) process large
                 data volumes under tight latency constraints. Many SPEs
                 execute processing pipelines using message passing on
                 shared-nothing architectures and apply a
                 partition-based scale-out strategy to handle
                 high-velocity input streams. Furthermore, many
                 state-of-the-art SPEs rely on a Java Virtual Machine to
                 achieve platform independence and speed up system
                 development by abstracting from the underlying
                 hardware. In this paper, we show that taking the
                 underlying hardware into account is essential to
                 exploit modern hardware efficiently. To this end, we
                 conduct an extensive experimental analysis of current
                 SPEs and SPE design alternatives optimized for modern
                 hardware. Our analysis highlights potential bottlenecks
                 and reveals that state-of-the-art SPEs are not capable
                 of fully exploiting current and emerging hardware
                 trends, such as multi-core processors and high-speed
                 networks. Based on our analysis, we describe a set of
                 design changes to the common architecture of SPEs to
                 scale-up on modern hardware. We show that the
                 single-node throughput can be increased by up to two
                 orders of magnitude compared to state-of-the-art SPEs
                 by applying specialized code generation, fusing
                 operators, batch-style parallelization strategies, and
                 optimized windowing. This speedup allows for deploying
                 typical streaming applications on a single or a few
                 nodes instead of large clusters.",
  acknowledgement = ack-nhfb,
  fjournal =     "Proceedings of the VLDB Endowment",
  journal-URL =  "http://portal.acm.org/citation.cfm?id=J1174",
}

@Article{Zhang:2019:DSJ,
  author =       "Dan Zhang and Dragan Bo{\v{s}}na{\v{c}}ki and Mark van
                 den Brand and Cornelis Huizing and Bart Jacobs and
                 Ruurd Kuiper and Anton Wijs",
  title =        "Dependency safety for {Java} --- {Implementing} and
                 testing failboxes",
  journal =      j-SCI-COMPUT-PROGRAM,
  volume =       "184",
  number =       "??",
  pages =        "??--??",
  day =          "1",
  month =        oct,
  year =         "2019",
  CODEN =        "SCPGD4",
  DOI =          "https://doi.org/10.1016/j.scico.2019.102316",
  ISSN =         "0167-6423 (print), 1872-7964 (electronic)",
  ISSN-L =       "0167-6423",
  bibdate =      "Wed May 26 13:33:17 MDT 2021",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/scicomputprogram.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0167642319301145",
  acknowledgement = ack-nhfb,
  articleno =    "102316",
  fjournal =     "Science of Computer Programming",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01676423",
}

@Article{Zhou:2019:AJM,
  author =       "Yu Zhou and Xin Yan and Wenhua Yang and Taolue Chen
                 and Zhiqiu Huang",
  title =        "Augmenting {Java} method comments generation with
                 context information based on neural networks",
  journal =      j-J-SYST-SOFTW,
  volume =       "156",
  number =       "??",
  pages =        "328--340",
  month =        oct,
  year =         "2019",
  CODEN =        "JSSODM",
  ISSN =         "0164-1212 (print), 1873-1228 (electronic)",
  ISSN-L =       "0164-1212",
  bibdate =      "Wed Oct 16 06:54:20 MDT 2019",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/jsystsoftw.bib",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0164121219301529",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Systems and Software",
  journal-URL =  "http://www.sciencedirect.com/science/journal/01641212",
}

%%% ====================================================================
%%% Cross-referenced entries must come last; entries are sorted by year,
%%% and then by citation label, with `bibsort --byyear':

@Proceedings{Forth:2012:RAA,
  editor =       "Shaun Forth and Paul Hovland and Eric Phipps and Jean
                 Utke and Andrea Walther",
  booktitle =    "Recent Advances in Algorithmic Differentiation",
  title =        "Recent Advances in Algorithmic Differentiation",
  volume =       "87",
  publisher =    pub-SV,
  address =      pub-SV:adr,
  pages =        "xvii + 353",
  year =         "2012",
  CODEN =        "LNCSA6",
  DOI =          "https://doi.org/10.1007/978-3-642-30023-3",
  ISBN =         "3-642-30022-7 (print), 3-642-30023-5 (e-book)",
  ISBN-13 =      "978-3-642-30022-6 (print), 978-3-642-30023-3
                 (e-book)",
  ISSN =         "1439-7358",
  ISSN-L =       "1439-7358",
  LCCN =         "????",
  bibdate =      "Thu Dec 20 14:35:56 MST 2012",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/lncse.bib",
  note =         "Proceedings of the Sixth International Conference on
                 Automatic Differentiation (AD2012) held July 23--27,
                 2012, in Fort Collins, Colorado, USA.",
  series =       ser-LNCSE,
  URL =          "http://link.springer.com/book/10.1007/978-3-642-30023-3;
                 http://www.springerlink.com/content/978-3-642-30023-3",
  acknowledgement = ack-nhfb,
  bookpages =    "xvii + 353",
  series-URL =   "http://link.springer.com/bookseries/3527",
  tableofcontents = "Leibniz Notation for Automatic Differentiation /
                 Bruce Christianson \\
                 Sparse Jacobian Construction for Mapped Grid
                 Visco-Resistive Magnetohydrodynamics / Daniel R.
                 Reynolds and Ravi Samtaney \\
                 Combining Automatic Differentiation Methods for
                 High-Dimensional Nonlinear Models / James A. Reed, Jean
                 Utke and Hany S. Abdel-Khalik \\
                 Application of Automatic Differentiation to an
                 Incompressible URANS Solver / Emre {\"O}zkaya, Anil
                 Nemili and Nicolas R. Gauger \\
                 Applying Automatic Differentiation to the Community
                 Land Model / Azamat Mametjanov, Boyana Norris, Xiaoyan
                 Zeng, Beth Drewniak and Jean Utke, et al \\
                 Using Automatic Differentiation to Study the
                 Sensitivity of a Crop Model / Claire Lauvernet, Laurent
                 Hasco{\"e}t, Fran{\c{c}}ois-Xavier Le Dimet and
                 Fr{\'e}d{\'e}ric Baret \\
                 Efficient Automatic Differentiation of Matrix Functions
                 / Peder A. Olsen, Steven J. Rennie and Vaibhava Goel
                 \\
                 Native Handling of Message-Passing Communication in
                 Data-Flow Analysis / Val{\'e}rie Pascual and Laurent
                 Hasco{\"e}t \\
                 Increasing Memory Locality by Executing Several Model
                 Instances Simultaneously / Ralf Giering and Michael
                 V{\"o}szligbeck \\
                 Adjoint Mode Computation of Subgradients for McCormick
                 Relaxations / Markus Beckers, Viktor Mosenkis and Uwe
                 Naumann \\
                 Evaluating an Element of the Clarke Generalized
                 Jacobian of a Piecewise Differentiable Function / Kamil
                 A. Khan and Paul I. Barton \\
                 The Impact of Dynamic Data Reshaping on Adjoint Code
                 Generation for Weakly-Typed Languages Such as Matlab /
                 Johannes Willkomm, Christian H. Bischof and H. Martin
                 B{\"u}cker \\
                 On the Efficient Computation of Sparsity Patterns for
                 Hessians / Andrea Walther \\
                 Exploiting Sparsity in Automatic Differentiation on
                 Multicore Architectures / Benjamin Letschert, Kshitij
                 Kulshreshtha, Andrea Walther, Duc Nguyen and Assefaw
                 Gebremedhin, et al \\
                 Automatic Differentiation Through the Use of Hyper-Dual
                 Numbers for Second Derivatives / Jeffrey A. Fike and
                 Juan J. Alonso \\
                 Connections Between Power Series Methods and Automatic
                 Differentiation",
  xxbookpages =  "xvii + 361",
  xxpages =      "xvii + 361",
}

@Proceedings{Hollingsworth:2012:SPI,
  editor =       "Jeffrey Hollingsworth",
  booktitle =    "{SC '12: Proceedings of the International Conference
                 on High Performance Computing, Networking, Storage and
                 Analysis, Salt Lake Convention Center, Salt Lake City,
                 UT, USA, November 10--16, 2012}",
  title =        "{SC '12: Proceedings of the International Conference
                 on High Performance Computing, Networking, Storage and
                 Analysis, Salt Lake Convention Center, Salt Lake City,
                 UT, USA, November 10--16, 2012}",
  publisher =    pub-IEEE,
  address =      pub-IEEE:adr,
  year =         "2012",
  ISBN =         "1-4673-0804-8",
  ISBN-13 =      "978-1-4673-0804-5",
  bibdate =      "Thu Nov 15 07:35:55 2012",
  bibsource =    "https://www.math.utah.edu/pub/bibnet/authors/d/dongarra-jack-j.bib;
                 https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/supercomputing2012.bib",
  acknowledgement = ack-nhfb,
}

@Proceedings{Kroening:2015:CAV,
  editor =       "Daniel Kroening and Corina S. P{\u{a}}s{\u{a}}reanu",
  booktitle =    "{Computer Aided Verification: 27th International
                 Conference, CAV 2015, San Francisco, CA, USA, July
                 18--24, 2015, Proceedings, Part I}",
  title =        "{Computer Aided Verification: 27th International
                 Conference, CAV 2015, San Francisco, CA, USA, July
                 18--24, 2015, Proceedings, Part I}",
  volume =       "9206",
  publisher =    pub-SV,
  address =      pub-SV:adr,
  bookpages =    "xxiii + 677 + 141",
  pages =        "xxiii + 677 + 141",
  year =         "2015",
  DOI =          "https://doi.org/10.1007/978-3-319-21690-4",
  ISBN =         "3-319-21689-9",
  ISBN-13 =      "978-3-319-21689-8",
  bibdate =      "Sat Jan 9 11:36:57 2016",
  bibsource =    "https://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 https://www.math.utah.edu/pub/tex/bib/lncs.bib;
                 https://www.math.utah.edu/pub/tex/bib/string-matching.bib",
  series =       ser-LNCS,
  URL =          "http://link.springer.com/book/10.1007/978-3-319-21690-4",
  acknowledgement = ack-nhfb,
}