%%% -*-BibTeX-*-
%%% ====================================================================
%%%  BibTeX-file{
%%%     author          = "Nelson H. F. Beebe",
%%%     version         = "1.75",
%%%     date            = "26 September 2014",
%%%     time            = "08:26:49 MDT",
%%%     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",
%%%     FAX             = "+1 801 581 4148",
%%%     URL             = "http://www.math.utah.edu/~beebe",
%%%     checksum        = "29528 17201 83671 852660",
%%%     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.75, year coverage looked
%%%                        like this:
%%%
%%%                             2010 (  94)    2012 ( 132)    2014 (  57)
%%%                             2011 (  69)    2013 (  84)
%%%
%%%                             Article:        408
%%%                             Book:            24
%%%                             InProceedings:    2
%%%                             Proceedings:      2
%%%
%%%                             Total entries:  436
%%%
%%%                        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 \circled \def \circled #1{(#1)}\fi" #
          "\ifx \undefined \k \let \k = \c \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,
                    FAX: +1 801 581 4148,
                    e-mail: \path|beebe@math.utah.edu|,
                            \path|beebe@acm.org|,
                            \path|beebe@computer.org| (Internet),
                    URL: \path|http://www.math.utah.edu/~beebe/|"}

%%% ====================================================================
%%% 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-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-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-FORM-METHODS-SYST-DES = "Formal Methods in System Design"}

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

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

@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-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-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-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-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-AUTO-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-SYS-SCI        = "Journal of Computer and System Sciences"}

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

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

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

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

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

@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-NETWORK-COMP-APPL   = "Journal of Network and Computer
                                  Applications"}

@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-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-NEUROIMAGE            = "NeuroImage"}

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

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

@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-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-SIM-SERIES            = "Simulation series"}

@String{j-SIMULATION            = "Simulation"}

@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-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-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-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-TOMS                  = "ACM Transactions on Mathematical Software"}

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

@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-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.

@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 =          "http://doi.acm.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 =    "http://portal.acm.org/;
                 http://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 =          "http://doi.acm.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 =    "http://portal.acm.org/;
                 http://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 =    "http://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 =          "http://dx.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 =    "http://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 =          "http://doi.acm.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/;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://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 =          "http://doi.acm.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 =    "http://portal.acm.org/;
                 http://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 =          "http://dx.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;
                 http://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 =          "http://doi.acm.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 =    "http://portal.acm.org/;
                 http://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 =          "http://dx.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 =    "http://www.computer.org/tpds/;
                 http://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/portal/web/csdl/transactions/tpds",
}

@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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://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{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;
                 http://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 =          "http://doi.acm.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 =    "http://portal.acm.org/;
                 http://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{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 =          "http://doi.acm.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 =    "http://portal.acm.org/;
                 http://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{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 =    "http://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 =    "http://portal.acm.org/;
                 http://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;
                 http://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 =          "http://doi.acm.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 =    "http://portal.acm.org/;
                 http://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{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 =          "http://doi.acm.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/;
                 http://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 =          "http://doi.acm.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 =    "http://portal.acm.org/;
                 http://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{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 =          "http://doi.acm.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 =    "http://portal.acm.org/;
                 http://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",
}

@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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =    "http://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 =          "http://doi.acm.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 =    "http://portal.acm.org/;
                 http://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 =          "http://doi.acm.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 =    "http://portal.acm.org/;
                 http://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 =          "http://doi.acm.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 =    "http://portal.acm.org/;
                 http://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 =          "http://dx.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 =    "http://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{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 =          "http://doi.acm.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/;
                 http://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 =          "http://dx.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 =    "http://computer.org/software/so2010/;
                 http://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 =          "http://doi.acm.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 =    "http://portal.acm.org/;
                 http://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 =          "http://doi.acm.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/;
                 http://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 =          "http://dx.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;
                 http://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 =          "http://doi.acm.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 =    "http://portal.acm.org/;
                 http://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 =    "http://portal.acm.org/;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://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{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 =          "http://doi.acm.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 =    "http://portal.acm.org/;
                 http://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 =          "http://doi.acm.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/;
                 http://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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/complngs.bib;
                 http://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 =          "http://dx.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;
                 http://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 =          "http://doi.acm.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 =    "http://portal.acm.org/;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://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 =          "http://dx.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;
                 http://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 http://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 =          "http://dx.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 =    "http://computer.org/software/so2010/;
                 http://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 =          "http://doi.acm.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 =    "http://portal.acm.org/;
                 http://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 =          "http://doi.acm.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 =    "http://portal.acm.org/;
                 http://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 =          "http://doi.acm.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 =    "http://portal.acm.org/;
                 http://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 =    "http://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{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 =          "http://doi.acm.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 =    "http://portal.acm.org/;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://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{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 =          "http://doi.acm.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 =    "http://portal.acm.org/;
                 http://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 =          "http://doi.acm.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 =    "http://portal.acm.org/;
                 http://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 =          "http://doi.acm.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 =    "http://portal.acm.org/;
                 http://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 =          "http://doi.acm.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 =    "http://portal.acm.org/;
                 http://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 =          "http://dx.doi.org/10.1145/1879097.1879075",
  ISSN =         "0736-721X",
  ISSN-L =       "0736-721X",
  bibdate =      "Mon Jan 10 13:57:43 MST 2011",
  bibsource =    "http://portal.acm.org/;
                 http://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 =          "http://doi.acm.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 =    "http://portal.acm.org/;
                 http://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 =          "http://dx.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 =    "http://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 =    "http://portal.acm.org/;
                 http://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 =          "http://dx.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 =    "http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://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 =          "http://doi.acm.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 =    "http://portal.acm.org/;
                 http://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 =          "http://doi.acm.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 =    "http://portal.acm.org/;
                 http://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{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;
                 http://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 =          "http://doi.acm.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/;
                 http://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 =          "http://doi.acm.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 =    "http://portal.acm.org/;
                 http://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 =    "http://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 =    "http://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 =          "http://doi.acm.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/;
                 http://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 =          "http://doi.acm.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 =    "http://portal.acm.org/;
                 http://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 =          "http://doi.acm.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 =    "http://portal.acm.org/;
                 http://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 =          "http://dx.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 =    "http://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 =          "http://doi.acm.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 =    "http://portal.acm.org/;
                 http://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 =          "http://doi.acm.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 =    "http://portal.acm.org/;
                 http://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 =          "http://doi.acm.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 =    "http://portal.acm.org/;
                 http://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 =          "http://doi.acm.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 =    "http://portal.acm.org/;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://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 =    "http://www.math.utah.edu/pub/tex/bib/common-lisp.bib;
                 http://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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://www.math.utah.edu/pub/tex/bib/matlab.bib;
                 http://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 =          "http://doi.acm.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/;
                 http://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 =          "http://doi.acm.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 =    "http://portal.acm.org/;
                 http://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 =          "http://doi.acm.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 =    "http://portal.acm.org/;
                 http://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 =          "http://doi.acm.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 =    "http://portal.acm.org/;
                 http://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 =          "http://doi.acm.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 =    "http://portal.acm.org/;
                 http://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 =          "http://dx.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;
                 http://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 http://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 =          "http://doi.acm.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 =    "http://www.acm.org/pubs/contents/journals/toms/;
                 http://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 =          "http://doi.acm.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 =    "http://portal.acm.org/;
                 http://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 =          "http://doi.acm.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 =    "http://portal.acm.org/;
                 http://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 =          "http://doi.acm.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/;
                 http://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 =          "http://doi.acm.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 =    "http://portal.acm.org/;
                 http://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 =          "http://doi.acm.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 =    "http://portal.acm.org/;
                 http://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 =          "http://doi.acm.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/;
                 http://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 =          "http://dx.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;
                 http://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 http://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 =    "http://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 =          "http://doi.acm.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 =    "http://portal.acm.org/;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://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 =          "http://dx.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;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://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{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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://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 =          "http://dx.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;
                 http://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 http://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 =          "http://dx.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;
                 http://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 http://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 =          "http://dx.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 =    "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)1097-024X;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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{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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/complngs.bib;
                 http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://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;
                 http://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 =          "http://dx.doi.org/10.1145/2070336.2070354",
  ISSN =         "0736-721X",
  ISSN-L =       "0736-721X",
  bibdate =      "Fri Apr 6 11:01:24 MDT 2012",
  bibsource =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =    "http://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 =          "http://dx.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 =    "http://www.computer.org/tc/;
                 http://www.math.utah.edu/pub/tex/bib/ieeetranscomput.bib;
                 http://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 =    "http://portal.acm.org/;
                 http://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 =          "http://dx.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/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =    "http://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;
                 http://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 =          "http://dx.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 =    "http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =    "http://www.math.utah.edu/pub/tex/bib/common-lisp.bib;
                 http://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 =    "http://www.math.utah.edu/pub/tex/bib/computsystscieng.bib;
                 http://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 =          "http://dx.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 =    "http://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 =          "http://dx.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;
                 http://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 http://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 =          "http://dx.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 =    "http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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/;
                 http://www.math.utah.edu/pub/tex/bib/cacm2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://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 =    "http://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 =    "http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://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 =    "http://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;
                 http://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 =    "http://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 =    "http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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{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 =    "http://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 =    "http://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 =          "http://dx.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;
                 http://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 http://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 =          "http://dx.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/;
                 http://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 =          "http://dx.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;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://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{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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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{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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://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 =          "http://dx.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;
                 http://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 =          "http://dx.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/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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;
                 http://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 http://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 =    "http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://www.math.utah.edu/pub/tex/bib/pvm.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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",
}

@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;
                 http://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 =          "http://dx.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;
                 http://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://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 =          "http://dx.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 =    "http://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;
                 http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib",
  note =         "Updated for JavaFX 1.3.",
  series =       "Developer's library",
}

@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 =    "http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =    "http://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{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;
                 http://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 =          "http://dx.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/;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 (electronic bk.), 1-4398-6903-0
                 (hardback), 1-4398-6903-0",
  ISBN-13 =      "978-1-4398-6904-8 (electronic bk.), 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;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://www.math.utah.edu/pub/tex/bib/matlab.bib;
                 http://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{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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =     "http://dx.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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =     "http://dx.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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =     "http://dx.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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =     "http://dx.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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =     "http://dx.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{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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =     "http://dx.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 =          "http://dx.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/;
                 http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://computer.org/computer/;
                 http://www.math.utah.edu/pub/tex/bib/computer2010.bib;
                 http://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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =     "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/computsystscieng.bib;
                 http://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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =     "http://dx.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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =     "http://dx.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{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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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{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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =     "http://dx.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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =     "http://dx.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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =     "http://dx.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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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/;
                 http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =    "http://www.math.utah.edu/pub/tex/bib/common-lisp.bib;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://doi.ieeecomputersociety.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 =    "http://www.math.utah.edu/pub/tex/bib/ieeemultimedia.bib;
                 http://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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =     "http://dx.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{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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =     "http://dx.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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =     "http://dx.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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/ieeesoft.bib;
                 http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =     "http://dx.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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =     "http://dx.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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/cryptography2010.bib;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =     "http://dx.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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/computscieng.bib;
                 http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =     "http://dx.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{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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://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",
}

@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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/compphyscomm2010.bib;
                 http://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 =    "http://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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =     "http://dx.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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =     "http://dx.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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =     "http://dx.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",
}

@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 =          "http://dx.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;
                 http://www.math.utah.edu/pub/tex/bib/compj2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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/;
                 http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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{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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =     "http://dx.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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =     "http://dx.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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =     "http://dx.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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =     "http://dx.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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =     "http://dx.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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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",
}

@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 =    "http://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",
  acknowledgement = ack-nhfb,
  subject =      "Java (Computer program language); Computer security;
                 Oracle (Computer file); Computer programming;
                 Standards",
}

@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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/computer2010.bib;
                 http://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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =     "http://dx.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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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{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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/compphyscomm2010.bib;
                 http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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{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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =     "http://dx.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{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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://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{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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =     "http://dx.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 =          "http://dx.doi.org/10.1145/2402709.2402699",
  ISSN =         "0736-721X",
  ISSN-L =       "0736-721X",
  bibdate =      "Sun May 5 10:05:12 MDT 2013",
  bibsource =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.doi.org/10.1145/2402709.2402685",
  ISSN =         "0736-721X",
  ISSN-L =       "0736-721X",
  bibdate =      "Sun May 5 10:05:12 MDT 2013",
  bibsource =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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{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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.doi.org/10.1007/978-3-642-30023-3_22",
  bibdate =      "Sat Dec 22 08:35:46 MST 2012",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =     "http://dx.doi.org/10.1007/978-3-642-30023-3",
  book-URL =     "http://www.springerlink.com/content/978-3-642-30023-3",
}

@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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =     "http://dx.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 =          "http://dx.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;
                 http://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =     "http://dx.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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =     "http://dx.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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/complngs.bib;
                 http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://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{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 =          "http://dx.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/;
                 http://www.math.utah.edu/pub/tex/bib/cacm2010.bib;
                 http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://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 =          "http://dx.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/;
                 http://www.math.utah.edu/pub/tex/bib/cacm2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigplan2010.bib;
                 http://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{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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =     "http://dx.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 =          "http://dx.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 =    "http://computer.org/computer/;
                 http://www.math.utah.edu/pub/tex/bib/computer2010.bib;
                 http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/computer2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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{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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =     "http://dx.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 =          "http://dx.doi.org/10.1145/2229156.2229160",
  ISSN =         "2158-656X",
  bibdate =      "Tue Nov 6 19:02:09 MST 2012",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tmis/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =     "http://dx.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 =          "http://dx.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;
                 http://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =     "http://dx.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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =     "http://dx.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;
                 http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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{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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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{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 =          "http://dx.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;
                 http://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://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 =          "http://dx.doi.org/10.1145/2132499.2132502",
  ISSN =         "0097-8418",
  ISSN-L =       "0097-8418",
  bibdate =      "Sat Nov 17 15:44:30 MST 2012",
  bibsource =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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;
                 http://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://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 =          "http://dx.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;
                 http://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 http://www.math.utah.edu/pub/tex/bib/cryptography2010.bib;
                 http://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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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",
}

@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;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2000.bib;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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{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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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/;
                 http://www.math.utah.edu/pub/tex/bib/compsurv.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)1097-024X;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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{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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://www.math.utah.edu/pub/tex/bib/multithreading.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://www.math.utah.edu/pub/tex/bib/multithreading.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigplan2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =    "http://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 =          "http://dx.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;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.doi.org/10.1145/2658982.2527277",
  ISSN =         "0736-721X",
  bibdate =      "Wed Sep 3 16:38:30 MDT 2014",
  bibsource =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/cryptography2010.bib;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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{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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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{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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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;
                 http://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib",
  note =         "Foreword by Heinz Kabutz.",
  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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)1097-024X;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://www.math.utah.edu/pub/tex/bib/multithreading.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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{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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =    "http://www.math.utah.edu/pub/tex/bib/computsystscieng.bib;
                 http://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 others",
  title =        "The {Java} language specification",
  publisher =    pub-PH,
  address =      pub-PH:adr,
  edition =      "Fourth",
  pages =        "????",
  year =         "2013",
  ISBN =         "0-13-326022-4 (paperback)",
  ISBN-13 =      "978-0-13-326022-9 (paperback)",
  LCCN =         "????",
  bibdate =      "Mon Jan 28 14:57:19 MST 2013",
  bibsource =    "fsz3950.oclc.org:210/WorldCat;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib",
  acknowledgement = ack-nhfb,
  remark =       "Previous ed.: Boston, Mass.; London: Addison-Wesley,
                 2005.",
  subject =      "Java (Computer program language)",
  xxaddress =    "Harlow",
}

@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 =          "http://dx.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;
                 http://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 http://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 =    "http://www.math.utah.edu/pub/tex/bib/complngs.bib;
                 http://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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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",
}

@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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =    "http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigplan2010.bib;
                 http://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{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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/csharp.bib;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigplan2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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{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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =    "http://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:JVM,
  author =       "Tim Lindholm and others",
  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;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib",
  series =       "The Java series",
  acknowledgement = ack-nhfb,
  subject =      "Java (Computer program language)",
  xxaddress =    "Harlow",
}

@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 =          "http://dx.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/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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",
}

@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 =          "http://dx.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 =    "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)1097-024X;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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{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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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{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 =          "http://dx.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/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigplan2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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{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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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;
                 http://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 http://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 =          "http://dx.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 =    "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)1097-024X;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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;
                 http://www.math.utah.edu/pub/tex/bib/compj2010.bib;
                 http://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 =          "http://dx.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;
                 http://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 http://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",
}

@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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigplan2010.bib;
                 http://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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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",
}

@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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.doi.org/10.1145/2534973",
  ISSN =         "1946-6226",
  bibdate =      "Wed Nov 13 17:27:51 MST 2013",
  bibsource =    "http://www.acm.org/pubs/toce;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://www.math.utah.edu/pub/tex/bib/tissec.bib;
                 http://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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.doi.org/10.1145/2658982.2527285",
  ISSN =         "0736-721X",
  bibdate =      "Wed Sep 3 16:38:30 MDT 2014",
  bibsource =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://www.math.utah.edu/pub/tex/bib/multithreading.bib;
                 http://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{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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/cryptography2010.bib;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigplan2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://onlinelibrary.wiley.com/journal/10.1002/(ISSN)1097-024X;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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{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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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{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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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{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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigplan2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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{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 =          "http://dx.doi.org/10.1145/2555596",
  ISSN =         "2158-656X",
  bibdate =      "Tue Apr 15 17:44:19 MDT 2014",
  bibsource =    "http://www.acm.org/pubs/contents/journals/tmis/;
                 http://www.math.utah.edu/pub/tex/bib/gnu.bib;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =    "http://www.math.utah.edu/pub/tex/bib/complngs.bib;
                 http://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{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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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{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 =          "http://dx.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 =    "http://www.math.utah.edu/pub/tex/bib/ccpe.bib;
                 http://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{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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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{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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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:??",
  month =        feb,
  year =         "2014",
  CODEN =        "ACMSCU",
  DOI =          "http://dx.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 =    "http://www.acm.org/pubs/contents/journals/toms/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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{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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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{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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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{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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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{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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib
                 http://www.math.utah.edu/pub/tex/bib/sigplan2010.bib;
                 http://www.math.utah.edu/pub/tex/bib/s-plus.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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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: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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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{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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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{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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =    "http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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{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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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{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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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{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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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",
}

@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 =          "http://doi.ieeecomputersociety.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 =    "http://www.math.utah.edu/pub/tex/bib/ieeesoft.bib;
                 http://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 =          "http://dx.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/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://www.math.utah.edu/pub/tex/bib/matlab.bib;
                 http://www.math.utah.edu/pub/tex/bib/sciprog.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Scientific Programming",
  journal-URL =  "http://iospress.metapress.com/content/1058-9244",
}

@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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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{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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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.",
}

@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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib
                 http://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 =          "http://dx.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 =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/java2010.bib;
                 http://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