text:
32978-4",
  LCCN =         "????",
  bibdate =      "Thu Apr 16 13:03:27 2009",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib",
  acknowledgement = ack-nhfb,
}

@Article{Beazley:2009:PGB,
  author =       "David Beazley",
  title =        "{Python 3}: The Good, the Bad, and the Ugly",
  journal =      j-LOGIN,
  volume =       "34",
  number =       "2",
  pages =        "??--??",
  month =        apr,
  year =         "2009",
  CODEN =        "LOGNEM",
  ISSN =         "1044-6397",
  ISSN-L =       "1044-6397",
  bibdate =      "Fri Dec 7 11:34:39 MST 2012",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://www.math.utah.edu/pub/tex/bib/usenix2000.bib;
                 https://www.usenix.org/publications/login",
  URL =          "https://www.usenix.org/publications/login/april-2009-volume-34-number-2/python-3-good-bad-and-ugly",
  acknowledgement = ack-nhfb,
  fjournal =     ";login: the USENIX Association newsletter",
}

@Book{Bird:2009:NLP,
  author =       "Steven Bird and Ewan Klein and Edward Loper",
  title =        "Natural Language Processing with {Python}",
  publisher =    pub-ORA,
  address =      pub-ORA:adr,
  pages =        "500 (est)",
  year =         "2009",
  ISBN =         "0-596-51649-5",
  ISBN-13 =      "978-0-596-51649-9",
  LCCN =         "????",
  bibdate =      "Thu Apr 16 13:05:00 2009",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib",
  acknowledgement = ack-nhfb,
}

@Article{Boland:2009:IPD,
  author =       "Michael G. Boland and Curtis Clifton",
  title =        "Introducing {PyLighter}: dynamic code highlighter",
  journal =      j-SIGCSE,
  volume =       "41",
  number =       "1",
  pages =        "489--493",
  month =        mar,
  year =         "2009",
  CODEN =        "SIGSD3",
  DOI =          "http://dx.doi.org/10.1145/1539024.1509037",
  ISSN =         "0097-8418",
  ISSN-L =       "0097-8418",
  bibdate =      "Sat Nov 17 15:44:19 MST 2012",
  bibsource =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigcse2000.bib",
  note =         "Proceedings of SIGCSE '09.",
  abstract =     "Like a screenplay, a program is both a static artifact
                 and instructions for a dynamic performance. This
                 duality can keep laypeople from appreciating the
                 complexity of software systems and can be a stumbling
                 block for novice programmers. PyLighter lets laypeople
                 and novice programmers perceive the relationship
                 between static Python code and its execution. PyLighter
                 works with everything from simple console applications
                 to arcade-style games, and because PyLighter is easy to
                 adopt and use, instructors can integrate it into any
                 Python-based introductory course without changing the
                 rest of their syllabus.",
  acknowledgement = ack-nhfb,
  fjournal =     "SIGCSE Bulletin (ACM Special Interest Group on
                 Computer Science Education)",
}

@Article{Brune:2009:PUR,
  author =       "Corey Brune",
  title =        "{Python}: An Untapped Resource in System
                 Administration",
  journal =      j-LOGIN,
  volume =       "34",
  number =       "1",
  pages =        "??--??",
  month =        feb,
  year =         "2009",
  CODEN =        "LOGNEM",
  ISSN =         "1044-6397",
  ISSN-L =       "1044-6397",
  bibdate =      "Fri Dec 7 11:34:38 MST 2012",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://www.math.utah.edu/pub/tex/bib/usenix2000.bib;
                 https://www.usenix.org/publications/login",
  URL =          "https://www.usenix.org/publications/login/february-2009-volume-34-number-1/python-untapped-resource-system-administration",
  acknowledgement = ack-nhfb,
  fjournal =     ";login: the USENIX Association newsletter",
}

@Book{Donaldson:2009:P,
  author =       "Toby Donaldson",
  title =        "{Python}",
  publisher =    pub-PEACHPIT,
  address =      pub-PEACHPIT:adr,
  edition =      "Second",
  pages =        "vi + 185",
  year =         "2009",
  ISBN =         "0-321-58544-5 (paperback)",
  ISBN-13 =      "978-0-321-58544-8 (paperback)",
  LCCN =         "X09.F00872",
  bibdate =      "Thu Apr 16 10:54:00 MDT 2009",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 library.ox.ac.uk:210/ADVANCE",
  series =       "Visual quickstart guide",
  acknowledgement = ack-nhfb,
  subject =      "Python (Computer program language)",
}

@Book{Downey:2009:PSD,
  author =       "Allen Downey",
  title =        "{Python} for software design: how to think like a
                 computer scientist",
  publisher =    pub-CAMBRIDGE,
  address =      pub-CAMBRIDGE:adr,
  pages =        "????",
  year =         "2009",
  ISBN =         "0-521-89811-0, 0-521-72596-8",
  ISBN-13 =      "9780521898119, 9780521725965",
  LCCN =         "QA76.73.P98 D693 2009",
  bibdate =      "Thu Apr 16 12:09:42 MDT 2009",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 z3950.loc.gov:7090/Voyager",
  acknowledgement = ack-nhfb,
  subject =      "Python (Computer program language)",
}

@Article{Drummond:2009:PPB,
  author =       "L. Anthony Drummond and Vicente Galiano and Violeta
                 Migall{\'o}n and Jose Penad{\'e}s",
  title =        "{PyACTS}: {A} {Python} Based Interface to {ACTS} Tools
                 and Parallel Scientific Applications",
  journal =      j-INT-J-PARALLEL-PROG,
  volume =       "37",
  number =       "1",
  pages =        "58--77",
  month =        feb,
  year =         "2009",
  CODEN =        "IJPPE5",
  ISSN =         "0885-7458 (print), 1573-7640 (electronic)",
  ISSN-L =       "0885-7458",
  bibdate =      "Wed Sep 1 16:06:47 MDT 2010",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://springerlink.metapress.com/openurl.asp?genre=issue&issn=0885-7458&volume=37&issue=1",
  URL =          "http://www.springerlink.com/openurl.asp?genre=article&issn=0885-7458&volume=37&issue=1&spage=58",
  acknowledgement = ack-nhfb,
}

@Article{Enbody:2009:PCP,
  author =       "Richard J. Enbody and William F. Punch and Mark
                 McCullen",
  title =        "{Python CS1} as preparation for {C++ CS2}",
  journal =      j-SIGCSE,
  volume =       "41",
  number =       "1",
  pages =        "116--120",
  month =        mar,
  year =         "2009",
  CODEN =        "SIGSD3",
  DOI =          "http://dx.doi.org/10.1145/1539024.1508907",
  ISSN =         "0097-8418",
  ISSN-L =       "0097-8418",
  bibdate =      "Sat Nov 17 15:44:19 MST 2012",
  bibsource =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigcse2000.bib",
  note =         "Proceedings of SIGCSE '09.",
  abstract =     "How suitable is a Python-based CS1 course as
                 preparation for a C++-based CS2 course? After fifteen
                 years of using C++ for both CS1 and CS2, the Computer
                 Science Department at Michigan State University changed
                 the CS1 course to Python. This paper examines the
                 impact of that change on the second course in the
                 sequence, CS2, which kept C++ as its primary language.
                 We report results on a CS2 class which had a mixture of
                 students who had used either C++ or Python from our CS1
                 course. The CS2 class covered the same topics as
                 previously, though with some changes, and even gave the
                 same final exam as a previous offering. Independent
                 samples t-tests were used to compare students from the
                 Python group with students from the non-Python group on
                 three outcomes: final exam grade, programming projects
                 scores, and final grade for the course. The main result
                 was that there were no significant differences between
                 the groups for all three outcomes. In addition,
                 multiple regression analysis showed that students' past
                 performance (overall GPA) in the University predicted
                 final grades, final exam scores, and programming
                 project scores for the course, but there was no effect
                 of the programming language feature: Python or
                 non-Python. We feel this shows that the Python-based
                 CS1 course prepared students for the C++-based CS2
                 course as well as the C++-based CS1 course did---while
                 exposing them to a different, powerful and useful
                 language.",
  acknowledgement = ack-nhfb,
  fjournal =     "SIGCSE Bulletin (ACM Special Interest Group on
                 Computer Science Education)",
}

@Book{Ernesti:2009:PUH,
  author =       "Johannes Ernesti and Peter Kaiser",
  title =        "{Python 3: Das umfassende Handbuch}",
  publisher =    "Galileo Press GmbH",
  address =      "Bonn, Germany",
  edition =      "Second",
  pages =        "870 (est.)",
  year =         "2009",
  ISBN =         "3-8362-1412-1",
  ISBN-13 =      "9783836214124",
  LCCN =         "????",
  bibdate =      "Thu Apr 16 12:01:42 MDT 2009",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 z3950.gbv.de:20011/gvk",
  price =        "EUR 39.90",
  series =       "Galileo Computing",
  acknowledgement = ack-nhfb,
  language =     "German",
}

@Book{Forcier:2009:PWD,
  author =       "Jeff Forcier and Paul Bissex and Wesley Chun",
  title =        "{Python Web} development with {Django}",
  publisher =    pub-AW,
  address =      pub-AW:adr,
  pages =        "377",
  year =         "2009",
  ISBN =         "0-13-235613-9 (paperback)",
  ISBN-13 =      "978-0-13-235613-8 (paperback)",
  LCCN =         "TK5105.8885.D54 F68 2009",
  bibdate =      "Thu Apr 16 12:09:18 MDT 2009",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 z3950.loc.gov:7090/Voyager",
  series =       "Developer's library",
  acknowledgement = ack-nhfb,
  subject =      "Web site development; Django (Electronic resource);
                 Python (Computer program language); Web sites;
                 Authoring programs",
  tableofcontents = "Introduction 1\\
                 Part I: Getting Started \\
                 Chapter 1: Practical Python for Django 7\\
                 \\
                 Chapter 2: Django for the Impatient: Building a Blog 57
                 \\
                 Chapter 3: Starting Out 77 \\
                 Part II: Django in Depth \\
                 Chapter 4: Defining and Using Models 89 \\
                 Chapter 5: URLs, HTTP Mechanisms, and Views 117 \\
                 Chapter 6: Templates and Form Processing 135 \\
                 Part III: Django Applications by Example \\
                 Chapter 7: Photo Gallery 159 \\
                 Chapter 8: Content Management System 181 \\
                 Chapter 9: Liveblog 205 \\
                 Chapter 10: Pastebin 221 \\
                 Part IV: Advanced Django Techniques and Features \\
                 Chapter 11: Advanced Django Programming 235 \\
                 Chapter 12: Advanced Django Deployment 261 \\
                 Part V: Appendices \\
                 Appendix A: Command Line Basics 285 \\
                 Appendix B: Installing and Running Django 295 \\
                 Appendix C: Tools for Practical Django Development 313
                 \\
                 Appendix D: Finding, Evaluating, and Using Django
                 Applications 321 \\
                 Appendix E: Django on the Google App Engine 325 \\
                 Appendix F: Getting Involved in the Django Project 337
                 \\
                 Index 339 \\
                 Colophon 375",
}

@Article{Furr:2009:PGS,
  author =       "Michael Furr and Jong-hoon (David) An and Jeffrey S.
                 Foster",
  title =        "Profile-guided static typing for dynamic scripting
                 languages",
  journal =      j-SIGPLAN,
  volume =       "44",
  number =       "10",
  pages =        "283--300",
  month =        oct,
  year =         "2009",
  CODEN =        "SINODQ",
  DOI =          "http://doi.acm.org/10.1145/1640089.1640110",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Mon Jun 21 18:01:56 MDT 2010",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://portal.acm.org/",
  abstract =     "Many popular scripting languages such as Ruby, Python,
                 and Perl include highly dynamic language constructs,
                 such as an eval method that evaluates a string as
                 program text. While these constructs allow terse and
                 expressive code, they have traditionally obstructed
                 static analysis. In this paper we present PRuby, an
                 extension to Diamondback Ruby (DRuby), a static type
                 inference system for Ruby. PRuby augments DRuby with a
                 novel dynamic analysis and transformation that allows
                 us to precisely type uses of highly dynamic constructs.
                 PRuby's analysis proceeds in three steps. First, we use
                 run-time instrumentation to gather per-application
                 profiles of dynamic feature usage. Next, we replace
                 dynamic features with statically analyzable
                 alternatives based on the profile. We also add
                 instrumentation to safely handle cases when subsequent
                 runs do not match the profile. Finally, we run DRuby's
                 static type inference on the transformed code to
                 enforce type safety.\par

                 We used PRuby to gather profiles for a benchmark suite
                 of sample Ruby programs. We found that dynamic features
                 are pervasive throughout the benchmarks and the
                 libraries they include, but that most uses of these
                 features are highly constrained and hence can be
                 effectively profiled. Using the profiles to guide type
                 inference, we found that DRuby can generally statically
                 type our benchmarks modulo some refactoring, and we
                 discovered several previously unknown type errors.
                 These results suggest that profiling and transformation
                 is a lightweight but highly effective approach to bring
                 static typing to highly dynamic languages.",
  acknowledgement = ack-nhfb,
  keywords =     "profile guided analysis; RIL; ruby; scripting
                 languages",
}

@Book{Gaddis:2009:SP,
  author =       "Tony Gaddis",
  title =        "Starting out with {Python}",
  publisher =    "Pearson Addison Wesley",
  address =      "Boston, MA, USA",
  pages =        "xv + 482",
  year =         "2009",
  ISBN =         "0-321-53711-4",
  ISBN-13 =      "978-0-321-53711-9",
  LCCN =         "QA76.73.P98 G34 2009",
  bibdate =      "Thu Apr 16 08:59:10 MDT 2009",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 z3950.loc.gov:7090/Voyager",
  URL =          "http://www.loc.gov/catdir/toc/fy0804/2008001684.html",
  acknowledgement = ack-nhfb,
  subject =      "Python (Computer program language)",
  tableofcontents = "Introduction to computers and programming \\
                 Input, processing, and output \\
                 Simple functions \\
                 Decision structures and Boolean logic \\
                 Repetition structures \\
                 Value-returning functions and modules \\
                 Files and exceptions \\
                 Working with sequences: strings and lists \\
                 Classes and object-oriented programming \\
                 Inheritance \\
                 Recursion \\
                 GUI programming \\
                 Appendix A: Installing Python \\
                 Appendix B: Introduction to IDLE \\
                 Appendix C: The ASCII character set",
}

@Book{Gardner:2009:DGP,
  author =       "James Gardner",
  title =        "The definitive guide to {Pylons}: [{Pylons} is a
                 lightweight web framework emphasizing flexibility and
                 rapid development using standard tools from the
                 {Python} community ; includes {SQLAlchemy},
                 {JavaScript}, and {WSG}!]",
  publisher =    pub-APRESS,
  address =      pub-APRESS:adr,
  pages =        "xxv + 536",
  year =         "2009",
  ISBN =         "1-59059-934-9 (paperback)",
  ISBN-13 =      "978-1-59059-934-1 (paperback)",
  LCCN =         "????",
  bibdate =      "Thu Apr 16 12:30:45 MDT 2009",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 z3950.gbv.de:20011/gvk",
  price =        "US\$46,99",
  series =       "The expert's voice in web development; Books for
                 professionals by professionals",
  acknowledgement = ack-nhfb,
}

@Article{Goldwasser:2009:GPF,
  author =       "Michael H. Goldwasser and David Letscher",
  title =        "A graphics package for the first day and beyond",
  journal =      j-SIGCSE,
  volume =       "41",
  number =       "1",
  pages =        "206--210",
  month =        mar,
  year =         "2009",
  CODEN =        "SIGSD3",
  DOI =          "http://dx.doi.org/10.1145/1539024.1508945",
  ISSN =         "0097-8418",
  ISSN-L =       "0097-8418",
  bibdate =      "Sat Nov 17 15:44:19 MST 2012",
  bibsource =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigcse2000.bib",
  note =         "Proceedings of SIGCSE '09.",
  abstract =     "We describe cs1graphics, a new Python drawing package
                 designed with pedagogy in mind. The package is simple
                 enough that students can sit down and make use of it
                 from the first day of an introductory class. Yet it
                 provides seamless support for intermediate and advanced
                 lessons as students progress. In this paper, we discuss
                 its versatility in the context of an introductory
                 course. The package is available at
                 www.cs1graphics.org.",
  acknowledgement = ack-nhfb,
  fjournal =     "SIGCSE Bulletin (ACM Special Interest Group on
                 Computer Science Education)",
}

@Article{Guyer:2009:FPD,
  author =       "Jonathan E. Guyer and Daniel Wheeler and James A.
                 Warren",
  title =        "{FiPy}: Partial Differential Equations with {Python}",
  journal =      j-COMPUT-SCI-ENG,
  volume =       "11",
  number =       "3",
  pages =        "6--15",
  month =        may # "\slash " # jun,
  year =         "2009",
  CODEN =        "CSENFA",
  DOI =          "http://dx.doi.org/10.1109/MCSE.2009.52",
  ISSN =         "1521-9615 (print), 1558-366X (electronic)",
  bibdate =      "Thu May 13 11:08:14 2010",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://www.computer.org/portal/web/csdl/magazines/cise",
  acknowledgement = ack-nhfb,
  fjournal =     "Computing in Science and Engineering",
}

@Article{Hambrusch:2009:MAT,
  author =       "Susanne Hambrusch and Christoph Hoffmann and John T.
                 Korb and Mark Haugan and Antony L. Hosking",
  title =        "A multidisciplinary approach towards computational
                 thinking for science majors",
  journal =      j-SIGCSE,
  volume =       "41",
  number =       "1",
  pages =        "183--187",
  month =        mar,
  year =         "2009",
  CODEN =        "SIGSD3",
  DOI =          "http://dx.doi.org/10.1145/1539024.1508931",
  ISSN =         "0097-8418",
  ISSN-L =       "0097-8418",
  bibdate =      "Sat Nov 17 15:44:19 MST 2012",
  bibsource =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigcse2000.bib",
  note =         "Proceedings of SIGCSE '09.",
  abstract =     "This paper describes the development and initial
                 evaluation of a new course ``Introduction to
                 Computational Thinking'' taken by science majors to
                 fulfill a college computing requirement. The course was
                 developed by computer science faculty in collaboration
                 with science faculty and it focuses on the role of
                 computing and computational principles in scientific
                 inquiry. It uses Python and Python libraries to teach
                 computational thinking via basic programming concepts,
                 data management concepts, simulation, and
                 visualization. Problems with a computational aspect are
                 drawn from different scientific disciplines and are
                 complemented with lectures from faculty in those areas.
                 Our initial evaluation indicates that the
                 problem-driven approach focused on scientific discovery
                 and computational principles increases the student's
                 interest in computing.",
  acknowledgement = ack-nhfb,
  fjournal =     "SIGCSE Bulletin (ACM Special Interest Group on
                 Computer Science Education)",
}

@Book{Kinser:2009:PB,
  author =       "Jason M. Kinser",
  title =        "{Python} for bioinformatics",
  publisher =    "Jones and Bartlett Publishers",
  address =      "Sudbury, MA, USA",
  pages =        "xvii + 417",
  year =         "2009",
  ISBN =         "0-7637-5186-3",
  ISBN-13 =      "9780763751869",
  LCCN =         "QH324.2.K55; QH324.2.K55 2009",
  bibdate =      "Thu Apr 16 12:32:38 MDT 2009",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 library.mit.edu:9909/mit01",
  series =       "Jones and Bartlett series in biomedical informatics",
  acknowledgement = ack-nhfb,
  remark =       "Ch. 1. Introduction \\
                 Ch. 2. NumPy and SciPy \\
                 Ch. 3. Image Manipulation \\
                 Ch. 4. The Akando and Dancer Modules \\
                 Ch. 5. Statistics \\
                 Ch. 6. Parsing DNA Data Files \\
                 Ch. 7. Sequence Alignment \\
                 Ch. 8. Dynamic Programming \\
                 Ch. 9. Tandem Repeats \\
                 Ch. 10. Hidden Markov Models \\
                 Ch. 11. Genetic Algorithms \\
                 Ch. 12. Multiple Sequence Alignment \\
                 Ch. 13. Gapped Alignments \\
                 Ch. 14. Trees \\
                 Ch. 15. Text Mining \\
                 Ch. 16. Measuring Complexity \\
                 Ch. 17. Clustering \\
                 Ch. 18. Self-Organizing Maps \\
                 Ch. 19. Principal Component Analysis \\
                 Ch. 20. Species Identification \\
                 Ch. 21. Fourier Transforms \\
                 Ch. 22. Correlations \\
                 Ch. 23. Numerical Sequence Alignment \\
                 Ch. 24. Gene Expression Array Files \\
                 Ch. 25. Spot Finding and Measurement \\
                 Ch. 26. Spreadsheet Arrays and Data Displays \\
                 Ch. 27. Applications with Expression Arrays",
  subject =      "Bioinformatics",
}

@Book{Langtangen:2009:PSP,
  author =       "Hans Petter Langtangen",
  title =        "A primer on scientific programming with {Python}",
  volume =       "6",
  publisher =    pub-SV,
  address =      pub-SV:adr,
  pages =        "xxvii + 693",
  year =         "2009",
  DOI =          "http://dx.doi.org/10.1007/978-3-642-02475-7",
  ISBN =         "3-642-02475-0, 3-642-02474-2",
  ISBN-13 =      "978-3-642-02475-7, 978-3-642-02474-0",
  ISSN =         "1611-0994",
  LCCN =         "QA76.73.P98 L286 2009",
  bibdate =      "Mon Jul 12 16:17:14 MDT 2010",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 library.mit.edu:9909/mit01",
  series =       "Texts in computational science and engineering",
  acknowledgement = ack-nhfb,
  subject =      "Python (Computer program language); mathematics;
                 computer science; software engineering; physics",
}

@Article{LeVeque:2009:PTR,
  author =       "Randall J. LeVeque",
  title =        "{Python} Tools for Reproducible Research on Hyperbolic
                 Problems",
  journal =      j-COMPUT-SCI-ENG,
  volume =       "11",
  number =       "1",
  pages =        "19--27",
  month =        jan # "\slash " # feb,
  year =         "2009",
  CODEN =        "CSENFA",
  DOI =          "http://dx.doi.org/10.1109/MCSE.2009.13",
  ISSN =         "1521-9615 (print), 1558-366X (electronic)",
  bibdate =      "Thu May 13 11:08:14 2010",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://www.computer.org/portal/web/csdl/magazines/cise",
  acknowledgement = ack-nhfb,
  fjournal =     "Computing in Science and Engineering",
}

@Book{Lewis:2009:HPP,
  author =       "Andrew Lewis",
  title =        "High performance {Python}",
  publisher =    pub-ORA,
  address =      pub-ORA:adr,
  pages =        "????",
  year =         "2009",
  ISBN =         "0-596-15996-X",
  ISBN-13 =      "978-0-596-15996-2",
  LCCN =         "????",
  bibdate =      "Thu Apr 16 13:02:33 2009",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib",
  acknowledgement = ack-nhfb,
}

@Article{Lister:2009:FER,
  author =       "Raymond Lister and Colin Fidge and Donna Teague",
  title =        "Further evidence of a relationship between explaining,
                 tracing and writing skills in introductory
                 programming",
  journal =      j-SIGCSE,
  volume =       "41",
  number =       "3",
  pages =        "161--165",
  month =        sep,
  year =         "2009",
  CODEN =        "SIGSD3",
  DOI =          "http://dx.doi.org/10.1145/1595496.1562930",
  ISSN =         "0097-8418",
  ISSN-L =       "0097-8418",
  bibdate =      "Sat Nov 17 15:44:23 MST 2012",
  bibsource =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigcse2000.bib",
  note =         "Proceedings of ITiCSE '09.",
  abstract =     "This paper reports on a replication of earlier studies
                 into a possible hierarchy of programming skills. In
                 this study, the students from whom data was collected
                 were at a university that had not provided data for
                 earlier studies. Also, the students were taught the
                 programming language ``Python'', which had not been
                 used in earlier studies. Thus this study serves as a
                 test of whether the findings in the earlier studies
                 were specific to certain institutions, student cohorts,
                 and programming languages. Also, we used a
                 non-parametric approach to the analysis, rather than
                 the linear approach of earlier studies. Our results are
                 consistent with the earlier studies. We found that
                 students who cannot trace code usually cannot explain
                 code, and also that students who tend to perform
                 reasonably well at code writing tasks have also usually
                 acquired the ability to both trace code and explain
                 code.",
  acknowledgement = ack-nhfb,
  fjournal =     "SIGCSE Bulletin (ACM Special Interest Group on
                 Computer Science Education)",
}

@Book{Lutz:2009:LPa,
  author =       "Mark Lutz",
  title =        "Learning {Python}",
  publisher =    pub-ORA,
  address =      pub-ORA:adr,
  edition =      "Fourth",
  pages =        "xlix + 1160",
  year =         "2009",
  ISBN =         "0-596-15806-8 (paperback)",
  ISBN-13 =      "978-0-596-15806-4 (paperback)",
  LCCN =         "QA76.73.P98 L877 2009",
  bibdate =      "Sat Nov 13 10:06:19 MST 2010",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 melvyl.cdlib.org:210/CDL90",
  acknowledgement = ack-nhfb,
  remark =       "Covers Python 2.6 and 3.x.",
  subject =      "Python (Computer program language); Object-oriented
                 programming (Computer science)",
}

@Book{Lutz:2009:LPb,
  author =       "Mark Lutz",
  title =        "Learning {Python}",
  publisher =    pub-ORA-MEDIA,
  address =      pub-ORA-MEDIA:adr,
  edition =      "Fourth",
  pages =        "????",
  year =         "2009",
  ISBN =         "0-596-80539-X",
  ISBN-13 =      "978-0-596-80539-5",
  LCCN =         "QA76.73.P98 L877 2009",
  bibdate =      "Sat Nov 13 10:06:19 MST 2010",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 prodorbis.library.yale.edu:7090/voyager;
                 melvyl.cdlib.org:210/CDL90",
  acknowledgement = ack-nhfb,
  subject =      "Python (Computer program language); Object-oriented
                 programming (Computer science)",
}

@Article{Martins:2009:POO,
  author =       "Joaquim R. R. A. Martins and Christopher Marriage and
                 Nathan Tedford",
  title =        "{pyMDO}: An Object-Oriented Framework for
                 Multidisciplinary Design Optimization",
  journal =      j-TOMS,
  volume =       "36",
  number =       "4",
  pages =        "20:1--20:25",
  month =        aug,
  year =         "2009",
  CODEN =        "ACMSCU",
  DOI =          "http://doi.acm.org/10.1145/1555386.1555389",
  ISSN =         "0098-3500 (print), 1557-7295 (electronic)",
  bibdate =      "Mon Aug 31 15:04:00 MDT 2009",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://www.acm.org/pubs/contents/journals/toms/",
  abstract =     "We present pyMDO, an object-oriented framework that
                 facilitates the usage and development of algorithms for
                 multidisciplinary optimization (MDO). The resulting
                 implementation of the MDO methods is efficient and
                 portable. The main advantage of the proposed framework
                 is that it is flexible, with a strong emphasis on
                 object-oriented classes and operator overloading, and
                 it is therefore useful for the rapid development and
                 evaluation of new MDO methods. The top layer interface
                 is programmed in Python and it allows for the layers
                 below the interface to be programmed in C, C++,
                 Fortran, and other languages. We describe an
                 implementation of pyMDO and demonstrate that we can
                 take advantage of object-oriented programming to obtain
                 intuitive, easy-to-read, and easy-to-develop codes that
                 are at the same time efficient. This allows developers
                 to focus on the new algorithms they are developing and
                 testing, rather than on implementation details.
                 Examples demonstrate the user interface and the
                 corresponding results show that the various MDO methods
                 yield the correct solutions.",
  acknowledgement = ack-nhfb,
  articleno =    "20",
}

@Article{Mentis:2009:RAD,
  author =       "Alexander S. Mentis",
  title =        "A robotics {API} dialect for type-safe robots:
                 translating {Myro} to {Ada}",
  journal =      j-SIGADA-LETTERS,
  volume =       "29",
  number =       "3",
  pages =        "91--102",
  month =        dec,
  year =         "2009",
  CODEN =        "AALEE5",
  DOI =          "http://doi.acm.org/10.1145/1653616.1647442",
  ISSN =         "0736-721X",
  bibdate =      "Mon Jun 21 14:04:37 MDT 2010",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://portal.acm.org/",
  abstract =     "In this paper, we present an Ada robotics API designed
                 to be used in teaching undergraduate-level computer
                 science. Our API is inspired by Myro, a Python-based
                 API, but we improve upon Myro's usability, readability,
                 modularity, and documentation by using features of the
                 Ada programming language and the GNAT Programming
                 Studio's documentation generation tool. The
                 encapsulation, abstraction, and data hiding provided by
                 Ada's packages make it easy for beginning programmers
                 to use the API for advanced tasks, while Ada's syntax
                 and readability allow educators to use the underlying
                 code later in a course or curriculum to illustrate more
                 advanced concepts to the same students as their
                 knowledge and experience grow.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGAda Ada Letters",
  keywords =     "Myro; scribbler; undergraduate computer science
                 education",
}

@Book{Miller:2009:PPC,
  author =       "Bradley N. Miller and David L. Ranum",
  title =        "{Python} programming in context",
  publisher =    "Jones and Bartlett Publishers",
  address =      "Sudbury, MA, USA",
  pages =        "xxv + 492",
  year =         "2009",
  ISBN =         "0-7637-4602-9 (paperback)",
  ISBN-13 =      "978-0-7637-4602-5 (paperback)",
  LCCN =         "QA76.73.P98 M544 2009",
  bibdate =      "Thu Apr 16 10:46:48 MDT 2009",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 z3950.loc.gov:7090/Voyager",
  acknowledgement = ack-nhfb,
  subject =      "Python (Computer program language)",
}

@Article{Misra:2009:MCT,
  author =       "Ananya Misra and Douglas Blank and Deepak Kumar",
  title =        "A music context for teaching introductory computing",
  journal =      j-SIGCSE,
  volume =       "41",
  number =       "3",
  pages =        "248--252",
  month =        sep,
  year =         "2009",
  CODEN =        "SIGSD3",
  DOI =          "http://dx.doi.org/10.1145/1595496.1562955",
  ISSN =         "0097-8418",
  ISSN-L =       "0097-8418",
  bibdate =      "Sat Nov 17 15:44:23 MST 2012",
  bibsource =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigcse2000.bib",
  note =         "Proceedings of ITiCSE '09.",
  abstract =     "We describe myro.chuck, a Python module for
                 controlling music synthesis, and its applications to
                 teaching introductory computer science. The module was
                 built within the Myro framework using the ChucK
                 programming language, and was used in an introductory
                 computer science course combining robots, graphics and
                 music. The results supported the value of music in
                 engaging students and broadening their view of computer
                 science.",
  acknowledgement = ack-nhfb,
  fjournal =     "SIGCSE Bulletin (ACM Special Interest Group on
                 Computer Science Education)",
}

@Article{Ochem:2009:MLP,
  author =       "Quentin Ochem",
  title =        "Multi-language programming with {Ada}",
  journal =      j-SIGADA-LETTERS,
  volume =       "29",
  number =       "3",
  pages =        "19--20",
  month =        dec,
  year =         "2009",
  CODEN =        "AALEE5",
  DOI =          "http://doi.acm.org/10.1145/1647420.1647431",
  ISSN =         "0736-721X",
  bibdate =      "Mon Jun 21 14:04:37 MDT 2010",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://portal.acm.org/",
  abstract =     "Building complex applications often requires putting
                 together pieces of software or requirements that have
                 not been made to work together in the first place.
                 Thinking of a project with a high integrity kernel
                 written in Ada, using a set of low level libraries and
                 drivers written in C or C++, with a graphical interface
                 done in Java and unit tests driven by python is not
                 thinking of science fiction anymore. It's actual
                 concrete and day-to-day work. Unfortunately, having all
                 of these technologies talking to each other is not
                 straightforward, and often requires a deep knowledge of
                 both sides of the technology and extensive manual
                 work.\par

                 In this tutorial, we'll first study how to interface
                 directly Ada with native languages, such as C or C++.
                 We'll then have a deep look at communications with
                 languages running on virtual machines, such as Java,
                 Python and the .NET framework. Finally, we'll see how
                 Ada can be interfaced with an arbitrary language using
                 a middleware solution, such as SOAP or CORBA We?ll see
                 how the communication can be manually done using low
                 level features and APIs, and how a substantial part of
                 this process can be automated using high level binding
                 generators.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGAda Ada Letters",
  keywords =     "Ada; APIs; communication; interfacing; languages;
                 middleware; programming; software; systems",
}

@Article{Pradal:2009:PPB,
  author =       "C. Pradal and F. Boudon and C. Nouguier and J. Chopard
                 and C. Godin",
  title =        "{PlantGL}: {A} {Python}-based geometric library for
                 {$3$D} plant modelling at different scales",
  journal =      j-GRAPH-MODELS,
  volume =       "71",
  number =       "1",
  pages =        "1--21",
  month =        jan,
  year =         "2009",
  CODEN =        "GRMOFM",
  DOI =          "http://dx.doi.org/10.1016/j.gmod.2008.10.001",
  ISSN =         "1524-0703 (print), 1524-0711 (electronic)",
  ISSN-L =       "1524-0703",
  bibdate =      "Sat Dec 10 08:38:11 MST 2011",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://www.math.utah.edu/pub/tex/bib/cvgip.bib;
                 http://www.sciencedirect.com/science/journal/15240703",
  URL =          "http://www.sciencedirect.com/science/article/pii/S1524070308000143",
  acknowledgement = ack-nhfb,
  fjournal =     "Graphical Models",
}

@Article{Ravitch:2009:AGL,
  author =       "Tristan Ravitch and Steve Jackson and Eric Aderhold
                 and Ben Liblit",
  title =        "Automatic generation of library bindings using static
                 analysis",
  journal =      j-SIGPLAN,
  volume =       "44",
  number =       "6",
  pages =        "352--362",
  month =        jun,
  year =         "2009",
  CODEN =        "SINODQ",
  DOI =          "http://doi.acm.org/10.1145/1543135.1542516",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Jun 16 14:41:16 MDT 2009",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://portal.acm.org/",
  abstract =     "High-level languages are growing in popularity.
                 However, decades of C software development have
                 produced large libraries of fast, time-tested,
                 meritorious code that are impractical to recreate from
                 scratch. Cross-language bindings can expose low-level C
                 code to high-level languages. Unfortunately, writing
                 bindings by hand is tedious and error-prone, while
                 mainstream binding generators require extensive manual
                 annotation or fail to offer the language features that
                 users of modern languages have come to expect.\par

                 We present an improved binding-generation strategy
                 based on static analysis of unannotated library source
                 code. We characterize three high-level idioms that are
                 not uniquely expressible in C's low-level type system:
                 array parameters, resource managers, and multiple
                 return values. We describe a suite of interprocedural
                 analyses that recover this high-level information, and
                 we show how the results can be used in a binding
                 generator for the Python programming language. In
                 experiments with four large C libraries, we find that
                 our approach avoids the mistakes characteristic of
                 hand-written bindings while offering a level of Python
                 integration unmatched by prior automated approaches.
                 Among the thousands of functions in the public
                 interfaces of these libraries, roughly 40\% exhibit the
                 behaviors detected by our static analyses.",
  acknowledgement = ack-nhfb,
  keywords =     "bindings; dataflow analysis; FFI; foreign function
                 interfaces; multi-language code reuse; static library
                 analysis",
}

@Book{Reed:2009:DSA,
  author =       "David M. Reed and John M. Zelle",
  title =        "Data structures and algorithms using {Python} and
                 {C++}",
  publisher =    "Franklin, Beedle and Associates, Inc.",
  address =      "Wilsonville, OR, USA",
  pages =        "????",
  year =         "2009",
  ISBN =         "1-59028-233-7",
  ISBN-13 =      "978-1-59028-233-5",
  LCCN =         "QA76.73.P98 R44 2009",
  bibdate =      "Thu Apr 16 12:10:06 MDT 2009",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 z3950.loc.gov:7090/Voyager",
  acknowledgement = ack-nhfb,
  remark =       "Builds on knowledge from a first course in computer
                 programming using Python. Makes a transition from
                 programming in Python to a data structures course and
                 programming in C++",
  subject =      "Python (Computer program language); C++ (Computer
                 program language); Data structures (Computer science);
                 Computer algorithms",
}

@Article{Riehl:2009:LEO,
  author =       "Jonathan Riehl",
  title =        "Language embedding and optimization in {Mython}",
  journal =      j-SIGPLAN,
  volume =       "44",
  number =       "12",
  pages =        "39--48",
  month =        dec,
  year =         "2009",
  CODEN =        "SINODQ",
  DOI =          "http://doi.acm.org/10.1145/1640134.1640141",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Aug 31 22:04:07 MDT 2010",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://portal.acm.org/",
  abstract =     "Mython is an extensible variant of the Python
                 programming language. Mython achieves extensibility by
                 adding a quotation mechanism that accepts an additional
                 parameter as well as the code being quoted. The
                 additional quotation parameter takes the form of a
                 Mython expression. Unlike other user code, Mython
                 evaluates the quotation parameter at compile-time. The
                 result of the compile-time expression is a function
                 that is used to both parse the quoted code, and extend
                 the compile-time environment. By explicitly passing the
                 compilation environment to compile-time quotation
                 functions, Mython's parameterized quotation allows
                 users to inject code into the language compiler.
                 Injected code can extend the language by modifying the
                 compilation phases, which are visible to the
                 compilation environment. The Mython language is
                 realized by the MyFront compiler, a tool for
                 translating Mython into Python byte-code modules. This
                 paper introduces the Mython language, describes the
                 implementation and usage of the MyFront tool, and shows
                 how MyFront can be used to implement domain-specific
                 optimizations using a little rewrite language.",
  acknowledgement = ack-nhfb,
  keywords =     "compile-time metaprogramming; extensible languages;
                 open compilers",
}

@Book{Scott:2009:PLP,
  author =       "Michael L. Scott",
  title =        "Programming Language Pragmatics",
  publisher =    pub-MORGAN-KAUFMANN,
  address =      pub-MORGAN-KAUFMANN:adr,
  edition =      "Third",
  pages =        "xxx + 910",
  year =         "2009",
  ISBN =         "0-12-374514-4",
  ISBN-13 =      "978-0-12-374514-9",
  LCCN =         "????",
  bibdate =      "Thu May 21 16:07:05 MDT 2009",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 z3950.gbv.de:20011/gvk",
  note =         "Many sections of the book are relegated to the
                 accompanying CD-ROM.",
  acknowledgement = ack-nhfb,
  keywords =     "awk; perl; python; ruby; sed; sh; tcl",
}

@Book{Seitz:2009:GPP,
  author =       "Justin Seitz",
  title =        "{Gray Hat Python}: {Python} programming for hackers
                 and reverse engineers",
  publisher =    pub-NO-STARCH,
  address =      pub-NO-STARCH:adr,
  pages =        "????",
  year =         "2009",
  ISBN =         "1-59327-192-1",
  ISBN-13 =      "978-1-59327-192-3",
  LCCN =         "QA76.9.A25 S457 2009",
  bibdate =      "Thu Apr 16 12:07:47 MDT 2009",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 z3950.loc.gov:7090/Voyager",
  acknowledgement = ack-nhfb,
  subject =      "Computer security; Python (Computer program
                 language)",
  tableofcontents = "Setting up your development environment \\
                 Debuggers and debugger design \\
                 Building a Windows debugger \\
                 PyDbg : a pure Python Windows debugger \\
                 Immunity debugger : the best of both worlds \\
                 Hooking \\
                 DLL and code injection \\
                 Fuzzing \\
                 Sulley \\
                 Fuzzing Windows drivers \\
                 DAPython -Scripting IDA Pro \\
                 PyEmu --- The scriptable emulator",
}

@Article{Shacham:2009:CAS,
  author =       "Ohad Shacham and Martin Vechev and Eran Yahav",
  title =        "{Chameleon}: adaptive selection of collections",
  journal =      j-SIGPLAN,
  volume =       "44",
  number =       "6",
  pages =        "408--418",
  month =        jun,
  year =         "2009",
  CODEN =        "SINODQ",
  DOI =          "http://doi.acm.org/10.1145/1542476.1542522",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Tue Jun 16 14:41:16 MDT 2009",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://portal.acm.org/",
  abstract =     "Languages such as Java and C\#, as well as scripting
                 languages like Python, and Ruby, make extensive use of
                 Collection classes. A collection implementation
                 represents a fixed choice in the dimensions of
                 operation time, space utilization, and synchronization.
                 Using the collection in a manner not consistent with
                 this fixed choice can cause significant performance
                 degradation. In this paper, we present CHAMELEON, a
                 low-overhead automatic tool that assists the programmer
                 in choosing the appropriate collection implementation
                 for her application. During program execution,
                 CHAMELEON computes elaborate trace and heap-based
                 metrics on collection behavior. These metrics are
                 consumed on-the-fly by a rules engine which outputs a
                 list of suggested collection adaptation strategies. The
                 tool can apply these corrective strategies
                 automatically or present them to the programmer. We
                 have implemented CHAMELEON on top of a IBM's J9
                 production JVM, and evaluated it over a small set of
                 benchmarks. We show that for some applications, using
                 CHAMELEON leads to a significant improvement of the
                 memory footprint of the application.",
  acknowledgement = ack-nhfb,
  keywords =     "bloat; collections; Java; semantic profiler",
}

@Book{Summerfield:2009:PPC,
  author =       "Mark Summerfield",
  title =        "Programming in {Python 3}: a complete introduction to
                 the {Python} language",
  publisher =    pub-AW,
  address =      pub-AW:adr,
  pages =        "xiv + 525",
  year =         "2009",
  ISBN =         "0-13-712929-7 (paperback)",
  ISBN-13 =      "978-0-13-712929-4 (paperback)",
  LCCN =         "QA76.73.P98 S86 2009",
  bibdate =      "Thu Apr 16 08:04:00 MDT 2009",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 z3950.loc.gov:7090/Voyager",
  series =       "Developer's library",
  acknowledgement = ack-nhfb,
  subject =      "Python (Computer program language); Object-oriented
                 programming (Computer science)",
}

@Book{Sweigart:2009:PPL,
  author =       "Albert Sweigart",
  title =        "Playing with {Python}: learn to program by making
                 games",
  publisher =    pub-NO-STARCH,
  address =      pub-NO-STARCH:adr,
  pages =        "????",
  year =         "2009",
  ISBN =         "1-59327-198-0 (paperback)",
  ISBN-13 =      "978-1-59327-198-5 (paperback)",
  LCCN =         "????",
  bibdate =      "Thu Apr 16 13:05:01 MDT 2009",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 library.tcd.ie:210/advance",
  acknowledgement = ack-nhfb,
  subject =      "Python (Computer program language); Computer games;
                 Programming",
}

@Book{Swinnen:2009:APA,
  author =       "G{\'e}rard Swinnen",
  title =        "Apprendre {\'a} programmer avec Python: objet,
                 multithreading, {\'e}v{\'e}nements, bases de
                 donn{\'e}es, programmation web, programmation
                 r{\'e}seau, Unicode",
  publisher =    pub-EYROLLES,
  address =      pub-EYROLLES:adr,
  pages =        "xviii + 341",
  year =         "2009",
  LCCN =         "????",
  bibdate =      "Thu Apr 16 12:00:29 MDT 2009",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 carmin.sudoc.abes.fr:210/ABES-Z39-PUBLIC",
  acknowledgement = ack-nhfb,
  language =     "French",
}

@Book{Theis:2009:EPC,
  author =       "Thomas Theis",
  title =        "{Einstieg in Python 3: [auf CD: Python 3 und alle
                 Code-Beispiele des Buchs ; f{\"u}r Programmanf{\"a}nger
                 und Umsteiger ; mit vielen Beispielen und
                 {\`e}Ubungsaufgaben ; inkl. objektorientierter
                 Programmierung, Datenbanken, Internet u.v.m.]}",
  publisher =    "Galileo Press",
  address =      "Bonn, Germany",
  edition =      "Second",
  pages =        "399",
  year =         "2009",
  ISBN =         "3-8362-1406-7",
  ISBN-13 =      "978-3-8362-1406-3",
  LCCN =         "????",
  bibdate =      "Thu Apr 16 12:02:26 MDT 2009",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 z3950.gbv.de:20011/gvk",
  price =        "EUR 24.90",
  series =       "Galileo computing",
  acknowledgement = ack-nhfb,
  language =     "German",
  remark =       "Mit Online-Aktualisierung unter
                 www.galileocomputing.de.",
}

@Article{Tohline:2009:CPM,
  author =       "Joel E. Tohline and Jinghya Ge and Wesley Even and
                 Erik Anderson",
  title =        "A Customized {Python} Module for {CFD} Flow Analysis
                 within {VisTrails}",
  journal =      j-COMPUT-SCI-ENG,
  volume =       "11",
  number =       "3",
  pages =        "68--73",
  month =        may # "\slash " # jun,
  year =         "2009",
  CODEN =        "CSENFA",
  DOI =          "http://dx.doi.org/10.1109/MCSE.2009.44",
  ISSN =         "1521-9615 (print), 1558-366X (electronic)",
  bibdate =      "Thu May 13 11:08:14 2010",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://www.computer.org/portal/web/csdl/magazines/cise",
  acknowledgement = ack-nhfb,
  fjournal =     "Computing in Science and Engineering",
}

@Book{Tosi:2009:MPD,
  author =       "Sandro Tosi",
  title =        "{Matplotlib} for {Python} developers: build remarkable
                 publication quality plots the easy way",
  publisher =    "Packt Publishing",
  address =      "Birmingham",
  pages =        "iv + 293",
  year =         "2009",
  ISBN =         "1-84719-790-6",
  ISBN-13 =      "978-1-84719-790-0",
  LCCN =         "QA76.73.P48 T67 2009",
  bibdate =      "Mon Jul 12 16:23:13 MDT 2010",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 aubrey.tamu.edu:7090/voyager; z3950.gbv.de:20011/gvk",
  series =       "From technologies to solutions",
  acknowledgement = ack-nhfb,
}

@Book{Vaingast:2009:BPV,
  author =       "Shai Vaingast",
  title =        "Beginning {Python} visualization: crafting visual
                 transformation scripts",
  publisher =    pub-APRESS,
  address =      pub-APRESS:adr,
  pages =        "xx + 363",
  year =         "2009",
  ISBN =         "1-4302-1843-6 (paperback)",
  ISBN-13 =      "978-1-4302-1843-2 (paperback)",
  LCCN =         "QA76.73.P98 V35 2009",
  bibdate =      "Mon Jul 12 15:08:11 MDT 2010",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 z3950.loc.gov:7090/Voyager",
  acknowledgement = ack-nhfb,
  subject =      "Python (Computer program language); Object-oriented
                 programming (Computer science)",
}

@Book{Weigend:2009:OPP,
  author =       "Michael Weigend",
  title =        "{Objektorientierte Programmierung mit Python 3.0}",
  publisher =    "REDLINE",
  address =      "Heidelberg, Neckar, Germany",
  edition =      "Fourth",
  pages =        "752",
  year =         "2009",
  ISBN =         "3-8266-1750-9",
  ISBN-13 =      "978-3-8266-1750-8",
  LCCN =         "????",
  bibdate =      "Thu Apr 16 11:58:18 MDT 2009",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 z3950.gbv.de:20011/gvk",
  price =        "EUR 39.95",
  series =       "mitp bei Redline",
  acknowledgement = ack-nhfb,
  language =     "German",
}

@Article{Alnaes:2010:ESC,
  author =       "Martin Sandve Aln{\ae}s and Kent-Andr{\'e} Mardal",
  title =        "On the efficiency of symbolic computations combined
                 with code generation for finite element methods",
  journal =      j-TOMS,
  volume =       "37",
  number =       "1",
  pages =        "6:1--6:26",
  month =        jan,
  year =         "2010",
  CODEN =        "ACMSCU",
  DOI =          "http://doi.acm.org/10.1145/1644001.1644007",
  ISSN =         "0098-3500 (print), 1557-7295 (electronic)",
  bibdate =      "Mon Mar 15 10:45:33 MDT 2010",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://www.acm.org/pubs/contents/journals/toms/",
  abstract =     "Efficient and easy implementation of variational forms
                 for finite element discretization can be accomplished
                 with metaprogramming. Using a high-level language like
                 Python and symbolic mathematics makes an abstract
                 problem definition possible, but the use of a low-level
                 compiled language is vital for run-time efficiency. By
                 generating low-level C++ code based on symbolic
                 expressions for the discrete weak form, it is possible
                 to accomplish a high degree of abstraction in the
                 problem definition while surpassing the run-time
                 efficiency of traditional hand written C++ codes. We
                 provide several examples where we demonstrate orders of
                 magnitude in speedup.",
  acknowledgement = ack-nhfb,
  articleno =    "6",
  keywords =     "automation; code generation; compiler; finite element;
                 metaprogramming; Variational forms",
}

@Article{Anderson:2010:UPS,
  author =       "Erik W. Anderson and Gilbert A. Preston and Claudio T.
                 Silva",
  title =        "Using {Python} for Signal Processing and
                 Visualization",
  journal =      j-COMPUT-SCI-ENG,
  volume =       "12",
  number =       "4",
  pages =        "90--95",
  month =        jul # "\slash " # aug,
  year =         "2010",
  DOI =          "http://dx.doi.org/10.1109/MCSE.2010.91",
  ISSN =         "1521-9615 (print), 1558-366X (electronic)",
  bibdate =      "Tue Jul 27 16:37:11 2010",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://www.computer.org/portal/web/csdl/magazines/cise",
  acknowledgement = ack-nhfb,
  fjournal =     "Computing in Science and Engineering",
}

@Book{Bassi:2010:PB,
  author =       "Sebastian Bassi",
  title =        "{Python} for bioinformatics",
  publisher =    pub-CRC,
  address =      pub-CRC:adr,
  pages =        "xxv + 584",
  year =         "2010",
  ISBN =         "1-58488-929-2 (paperback)",
  ISBN-13 =      "978-1-58488-929-8 (paperback)",
  LCCN =         "QH324.2 .B387 2010",
  bibdate =      "Thu Nov 15 17:15:53 MST 2012",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 z3950.loc.gov:7090/Voyager",
  series =       "Chapman and Hall/CRC mathematical and computational
                 biology series",
  acknowledgement = ack-nhfb,
  subject =      "Bioinformatics; Python (Computer program language)",
}

@Article{Blundell:2010:RTR,
  author =       "Colin Blundell and Arun Raghavan and Milo M. K.
                 Martin",
  title =        "{RETCON}: transactional repair without replay",
  journal =      j-COMP-ARCH-NEWS,
  volume =       "38",
  number =       "3",
  pages =        "258--269",
  month =        jun,
  year =         "2010",
  CODEN =        "CANED2",
  DOI =          "http://doi.acm.org/10.1145/1815961.1815995",
  ISSN =         "0163-5964 (ACM), 0884-7495 (IEEE)",
  bibdate =      "Tue Jul 6 14:11:46 MDT 2010",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://portal.acm.org/",
  abstract =     "Over the past decade there has been a surge of
                 academic and industrial interest in optimistic
                 concurrency, {\em i.e.\/} the speculative parallel
                 execution of code regions that have the semantics of
                 isolation. This work analyzes scalability bottlenecks
                 of workloads that use optimistic concurrency. We find
                 that one common bottleneck is updates to auxiliary
                 program data in otherwise non-conflicting operations,
                 {\em e.g.\/} reference count updates and hashtable
                 occupancy field increments.\par

                 To eliminate the performance impact of conflicts on
                 such auxiliary data, this work proposes RETCON, a
                 hardware mechanism that tracks the relationship between
                 input and output values symbolically and uses this
                 symbolic information to transparently repair the output
                 state of a transaction at commit. RETCON is inspired by
                 instruction replay-based mechanisms but exploits
                 simplifying properties of the nature of computations on
                 auxiliary data to perform repair {\em without\/}
                 replay. Our experiments show that RETCON provides
                 significant speedups for workloads that exhibit
                 conflicts on auxiliary data, including transforming a
                 transactionalized version of the Python interpreter
                 from a workload that exhibits no scaling to one that
                 exhibits near-linear scaling on 32 cores.",
  acknowledgement = ack-nhfb,
  keywords =     "parallel programming; transactional memory",
}

@Article{Gorbovitski:2010:AAO,
  author =       "Michael Gorbovitski and Yanhong A. Liu and Scott D.
                 Stoller and Tom Rothamel and Tuncay K. Tekle",
  title =        "Alias analysis for optimization of dynamic languages",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "12",
  pages =        "27--42",
  month =        dec,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "http://dx.doi.org/10.1145/1899661.1869635",
  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://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://portal.acm.org/",
  abstract =     "Dynamic languages such as Python allow programs to be
                 written more easily using high-level constructs such as
                 comprehensions for queries and using generic code.
                 Efficient execution of programs then requires powerful
                 optimizations - incrementalization of expensive queries
                 and specialization of generic code. Effective
                 incrementalization and specialization of dynamic
                 languages require precise and scalable alias analysis.
                 This paper describes the development and experimental
                 evaluation of a may-alias analysis for a full dynamic
                 object-oriented language, for program optimization by
                 incrementalization and specialization. The analysis is
                 flow-sensitive; we show that this is necessary for
                 effective optimization of dynamic languages. It uses
                 precise type analysis and a powerful form of context
                 sensitivity, called trace sensitivity, to further
                 improve analysis precision.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
}

@Article{Jankowski:2010:BRBa,
  author =       "Richard Jankowski",
  title =        "Book Review: {{\booktitle{Data Structures and
                 Algorithms Using Python and C++}}, by David M. Reed and
                 John Zelle Franklin, Beedle and Associates 2009}",
  journal =      j-SIGACT,
  volume =       "41",
  number =       "1",
  pages =        "13--15",
  month =        mar,
  year =         "2010",
  CODEN =        "SIGNDM",
  DOI =          "http://dx.doi.org/10.1145/1753171.1753174",
  ISSN =         "0163-5700 (print), 1943-5827 (electronic)",
  ISSN-L =       "0163-5700",
  bibdate =      "Tue Mar 20 14:39:00 MDT 2012",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/sigact.bib",
  note =         "See \cite{Reed:2009:DSA}.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGACT News",
}

@Book{Kiusalaas:2010:NMEb,
  author =       "Jaan Kiusalaas",
  title =        "Numerical methods in engineering with {Python}",
  publisher =    pub-CAMBRIDGE,
  address =      pub-CAMBRIDGE:adr,
  edition =      "Second",
  pages =        "x + 422",
  year =         "2010",
  ISBN =         "0-521-19132-7 (hardcover)",
  ISBN-13 =      "978-0-521-19132-6 (hardcover)",
  LCCN =         "TA345 .K584 2010",
  bibdate =      "Mon Jan 31 15:16:50 MST 2011",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 melvyl.cdlib.org:210/CDL90;
                 z3950.loc.gov:7090/Voyager",
  acknowledgement = ack-nhfb,
  subject =      "Python (computer program language); MATLAB;
                 engineering mathematics; data processing; numerical
                 analysis",
  subject =      "MATLAB; Python (Computer program language);
                 Engineering mathematics; Data processing; Numerical
                 analysis",
}

@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://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://portal.acm.org/",
  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",
  keywords =     "dynamic analysis; ffi bugs; foreign function
                 interfaces (FFI); java native interface (jni);
                 multilingual programs; python/C; specification;
                 specification generation",
}

@Article{Liu:2010:LFI,
  author =       "Yanhong A. Liu and Michael Gorbovitski and Scott D.
                 Stoller",
  title =        "A language and framework for invariant-driven
                 transformations",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "2",
  pages =        "55--64",
  month =        feb,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "http://doi.acm.org/10.1145/1837852.1621617",
  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://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://portal.acm.org/",
  abstract =     "This paper describes a language and framework that
                 allow coordinated transformations driven by invariants
                 to be specified declaratively, as invariant rules, and
                 applied automatically. The framework supports
                 incremental maintenance of invariants for program
                 design and optimization, as well as general
                 transformations for instrumentation, refactoring, and
                 other purposes. This paper also describes our
                 implementations for transforming Python and C programs
                 and experiments with successful applications of the
                 systems in generating efficient implementations from
                 clear and modular specifications, in instrumenting
                 programs for runtime verification, profiling, and
                 debugging, and in code refactoring.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  keywords =     "incremental maintenance; invariants; program
                 optimization; program transformation; runtime invariant
                 checking",
}

@Article{Logg:2010:DAF,
  author =       "Anders Logg and Garth N. Wells",
  title =        "{DOLFIN}: {Automated} finite element computing",
  journal =      j-TOMS,
  volume =       "37",
  number =       "2",
  pages =        "20:1--20:28",
  month =        apr,
  year =         "2010",
  CODEN =        "ACMSCU",
  DOI =          "http://doi.acm.org/10.1145/1731022.1731030",
  ISSN =         "0098-3500 (print), 1557-7295 (electronic)",
  bibdate =      "Wed Apr 21 11:39:57 MDT 2010",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://www.acm.org/pubs/contents/journals/toms/",
  abstract =     "We describe here a library aimed at automating the
                 solution of partial differential equations using the
                 finite element method. By employing novel techniques
                 for automated code generation, the library combines a
                 high level of expressiveness with efficient
                 computation. Finite element variational forms may be
                 expressed in near mathematical notation, from which
                 low-level code is automatically generated, compiled,
                 and seamlessly integrated with efficient
                 implementations of computational meshes and
                 high-performance linear algebra. Easy-to-use
                 object-oriented interfaces to the library are provided
                 in the form of a C++ library and a Python module. This
                 article discusses the mathematical abstractions and
                 methods used in the design of the library and its
                 implementation. A number of examples are presented to
                 demonstrate the use of the library in application
                 code.",
  acknowledgement = ack-nhfb,
  articleno =    "20",
  keywords =     "code generation; DOLFIN; FEniCS project; form
                 compiler",
}

@Article{Patil:2010:PBS,
  author =       "Anand Patil and David Huard and Christopher J.
                 Fonnesbeck",
  title =        "{{\tt PyMC}}: {Bayesian} Stochastic Modelling in
                 {Python}",
  journal =      j-J-STAT-SOFT,
  volume =       "35",
  number =       "4",
  pages =        "??--??",
  month =        jul,
  year =         "2010",
  CODEN =        "JSSOBK",
  ISSN =         "1548-7660",
  bibdate =      "Wed Aug 25 09:57:41 MDT 2010",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib",
  URL =          "http://www.jstatsoft.org/v35/i04",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Statistical Software",
  pubdates =     "Submitted 2008-12-22; Accepted 2010-01-22",
}

@Article{Pop:2010:ERH,
  author =       "Iustin Pop",
  title =        "Experience report: {Haskell} as a reagent: results and
                 observations on the use of {Haskell} in a {Python}
                 project",
  journal =      j-SIGPLAN,
  volume =       "45",
  number =       "9",
  pages =        "369--374",
  month =        sep,
  year =         "2010",
  CODEN =        "SINODQ",
  DOI =          "http://dx.doi.org/10.1145/1932681.1863595",
  ISSN =         "0362-1340 (print), 1523-2867 (print), 1558-1160
                 (electronic)",
  ISSN-L =       "0362-1340",
  bibdate =      "Wed Jan 26 15:13:43 MST 2011",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://portal.acm.org/",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
}

@Book{Summerfield:2010:PPC,
  author =       "Mark Summerfield",
  title =        "Programming in {Python 3}: a complete introduction to
                 the {Python} language",
  publisher =    pub-AW,
  address =      pub-AW:adr,
  edition =      "Second",
  pages =        "xvi + 630",
  year =         "2010",
  ISBN =         "0-321-68056-1 (paperback)",
  ISBN-13 =      "978-0-321-68056-3 (paperback)",
  LCCN =         "QA76.73.P98 S86 2010",
  bibdate =      "Thu Mar 25 12:43:08 MDT 2010",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 z3950.loc.gov:7090/Voyager",
  series =       "Developer's library",
  acknowledgement = ack-nhfb,
  subject =      "Python (computer program language); object-oriented
                 programming (computer science)",
}

@Article{Tabba:2010:ACP,
  author =       "Fuad Tabba",
  title =        "Adding concurrency in {Python} using a commercial
                 processor's hardware transactional memory support",
  journal =      j-COMP-ARCH-NEWS,
  volume =       "38",
  number =       "5",
  pages =        "12--19",
  month =        dec,
  year =         "2010",
  CODEN =        "CANED2",
  DOI =          "http://dx.doi.org/10.1145/1978907.1978911",
  ISSN =         "0163-5964 (ACM), 0884-7495 (IEEE)",
  bibdate =      "Fri May 13 11:25:46 MDT 2011",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://portal.acm.org/",
  abstract =     "This paper reports on our experiences of using a
                 commercial processor's best-effort hardware
                 transactional memory to improve concurrency in CPython,
                 the reference Python implementation. CPython protects
                 its data structures using a single global lock, which
                 inhibits parallelism when running multiple
                 threads.\par

                 We modified the CPython interpreter to use best-effort
                 hardware transactions available in Sun's Rock
                 processor, and fall back on the single global lock when
                 unable to commit in hardware. The modifications were
                 minimal; however, we had to restructure some of
                 CPython's shared data structures to handle false
                 conflicts arising from CPython's management of the
                 shared data. Our results show that the modified CPython
                 interpreter can run small, simple, workloads and scale
                 almost linearly, while improving the concurrency of
                 more complex workloads.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGARCH Computer Architecture News",
}

@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://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://portal.acm.org/",
  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",
  keywords =     "dynamic scripting languages; just-in-time compiler;
                 php",
}

@Article{Xia:2010:CSP,
  author =       "Xiao-Qin Xia and Michael McClelland and Yipeng Wang",
  title =        "Code Snippet: {{\tt PypeR}}, {A} {Python} Package for
                 Using {R} in {Python}",
  journal =      j-J-STAT-SOFT,
  volume =       "35",
  number =       "CS-2",
  pages =        "??--??",
  month =        jul,
  year =         "2010",
  CODEN =        "JSSOBK",
  ISSN =         "1548-7660",
  bibdate =      "Wed Aug 25 09:57:41 MDT 2010",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib",
  URL =          "http://www.jstatsoft.org/v35/c02",
  acknowledgement = ack-nhfb,
  fjournal =     "Journal of Statistical Software",
  pubdates =     "Submitted 2009-10-23; Accepted 2010-03-23",
}

@Article{Barry:2011:PA,
  author =       "Paul Barry",
  title =        "{Python} for {Android}",
  journal =      j-LINUX-J,
  volume =       "2011",
  number =       "203",
  pages =        "1:1--1:??",
  month =        mar,
  year =         "2011",
  CODEN =        "LIJOFX",
  ISSN =         "1075-3583 (print), 1938-3827 (electronic)",
  ISSN-L =       "1075-3583",
  bibdate =      "Fri Mar 18 09:08:58 MDT 2011",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://portal.acm.org/",
  acknowledgement = ack-nhfb,
  articleno =    "1",
  fjournal =     "Linux Journal",
}

@Article{Joyner:2011:OSC,
  author =       "David Joyner and Ond{\v{r}}ej {\v{C}}ert{\'\i}k and
                 Aaron Meurer and Brian E. Granger",
  title =        "Open source computer algebra systems: {SymPy}",
  journal =      j-ACM-COMM-COMP-ALGEBRA,
  volume =       "45",
  number =       "3--4",
  pages =        "225--234",
  month =        sep,
  year =         "2011",
  CODEN =        "????",
  DOI =          "http://dx.doi.org/10.1145/2110170.2110185",
  ISSN =         "1932-2232 (print), 1932-2240 (electronic)",
  ISSN-L =       "1932-2232",
  bibdate =      "Thu Jan 26 16:43:28 MST 2012",
  bibsource =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsam.bib; http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/gnu.bib;
                 http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigsam.bib",
  abstract =     "This survey will look at SymPy, a free and open source
                 computer algebra system started in 2005 by the second
                 author (O.{\v{C}}.). It is written entirely in Python,
                 available from http://sympy.org. SymPy is licensed
                 under the ``modified BSD'' license, as is its beautiful
                 logo designed by Fredrik Johansson.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM Communications in Computer Algebra",
  issue =        "177",
}

@Article{Klaver:2011:PC,
  author =       "Adrian Klaver",
  title =        "{Python} in the cloud",
  journal =      j-LINUX-J,
  volume =       "2011",
  number =       "210",
  pages =        "7:1--7:??",
  month =        oct,
  year =         "2011",
  CODEN =        "LIJOFX",
  ISSN =         "1075-3583 (print), 1938-3827 (electronic)",
  bibdate =      "Sun Nov 6 07:06:26 MST 2011",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/linux-journal.bib",
  acknowledgement = ack-nhfb,
  articleno =    "7",
  fjournal =     "Linux Journal",
}

@Article{Kormanyos:2011:APC,
  author =       "Christopher Kormanyos",
  title =        "{Algorithm 910}: {A} Portable {C++} Multiple-Precision
                 System for Special-Function Calculations",
  journal =      j-TOMS,
  volume =       "37",
  number =       "4",
  pages =        "45:1--45:??",
  month =        feb,
  year =         "2011",
  CODEN =        "ACMSCU",
  DOI =          "http://dx.doi.org/10.1145/1916461.1916469",
  ISSN =         "0098-3500 (print), 1557-7295 (electronic)",
  bibdate =      "Tue Mar 1 16:05:18 MST 2011",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://www.acm.org/pubs/contents/journals/toms/",
  abstract =     "This article presents a portable C++ system for
                 multiple precision calculations of special functions
                 called {\tt e\_float}. It has an extendible
                 architecture with a uniform C++ layer which can be used
                 with any suitably prepared MP type. The system
                 implements many high-precision special functions and
                 extends some of these to very large parameter ranges.
                 It supports calculations with 30 \ldots{} 300 decimal
                 digits of precision. Interoperabilities with
                 Microsoft's CLR, Python, and Mathematica{\reg} are
                 supported. The {\tt e\_float} system and its usage are
                 described in detail. Implementation notes, testing
                 results, and performance measurements are provided.",
  abstract =     "This article presents a portable C++ system for
                 multiple precision calculations of special functions
                 called {\tt e\_float}. It has an extendable
                 architecture with a uniform C++ layer which can be used
                 with any suitably prepared MP type. The system
                 implements many high-precision special functions and
                 extends some of these to very large parameter ranges.
                 It supports calculations with 30 \ldots{} 300 decimal
                 digits of precision. Interoperabilities with
                 Microsoft's CLR, Python, and Mathematica{\reg} are
                 supported. The {\tt e\_float} system and its usage are
                 described in detail. Implementation notes, testing
                 results, and performance measurements are provided.",
  acknowledgement = ack-nhfb,
  articleno =    "45",
  fjournal =     "ACM Transactions on Mathematical Software (TOMS)",
}

@Article{Lambert:2011:PBO,
  author =       "Emmanuel Lambert and Martin Fiers and Shavkat Nizamov
                 and Martijn Tassaert and Steven G. Johnson and Peter
                 Bienstman and Wim Bogaerts",
  title =        "{Python} Bindings for the {Open Source Electromagnetic
                 Simulator Meep}",
  journal =      j-COMPUT-SCI-ENG,
  volume =       "13",
  number =       "3",
  pages =        "53--65",
  month =        may # "\slash " # jun,
  year =         "2011",
  CODEN =        "CSENFA",
  DOI =          "http://dx.doi.org/10.1109/MCSE.2010.98",
  ISSN =         "1521-9615 (print), 1558-366X (electronic)",
  ISSN-L =       "1521-9615",
  bibdate =      "Fri Apr 1 22:44:30 2011",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Computing in Science and Engineering",
}

@Article{List:2011:FUT,
  author =       "Michael List and David Car",
  title =        "A {Fortran} unit-testing framework utilizing
                 templating and the {PyF95++} toolset",
  journal =      j-FORTRAN-FORUM,
  volume =       "30",
  number =       "1",
  pages =        "3--15",
  month =        apr,
  year =         "2011",
  CODEN =        "????",
  DOI =          "http://dx.doi.org/10.1145/1961363.1961364",
  ISSN =         "1061-7264 (print), 1931-1311 (electronic)",
  bibdate =      "Mon Mar 21 16:45:38 MDT 2011",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://portal.acm.org/",
  abstract =     "A simple unit testing framework has been developed
                 utilizing a templating capability and Python based
                 preprocessor for Fortran. The implementation of this
                 framework and its use for testing serial and parallel
                 components is discussed. The capability was
                 successfully applied to the development of a Fortran
                 Standard Template Library and associated toolsets.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM Fortran Forum",
}

@Article{Migallon:2011:PPL,
  author =       "H{\'e}ctor Migall{\'o}n and Violeta Migall{\'o}n and
                 Jos{\'e} Penad{\'e}s",
  title =        "A {Parallel Python} library for nonlinear systems",
  journal =      j-J-SUPERCOMPUTING,
  volume =       "58",
  number =       "3",
  pages =        "438--448",
  month =        dec,
  year =         "2011",
  CODEN =        "JOSUED",
  ISSN =         "0920-8542 (print), 1573-0484 (electronic)",
  ISSN-L =       "0920-8542",
  bibdate =      "Tue Dec 13 15:25:17 MST 2011",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://springerlink.metapress.com/openurl.asp?genre=issue&issn=0920-8542&volume=58&issue=3;
                 http://www.math.utah.edu/pub/tex/bib/jsuper.bib",
  URL =          "http://www.springerlink.com/openurl.asp?genre=article&issn=0920-8542&volume=58&issue=3&spage=438",
  acknowledgement = ack-nhfb,
  fjournal =     "The Journal of Supercomputing",
}

@Article{Millman:2011:PSE,
  author =       "K. Jarrod Millman and Michael Aivazis",
  title =        "{Python} for Scientists and Engineers",
  journal =      j-COMPUT-SCI-ENG,
  volume =       "13",
  number =       "2",
  pages =        "9--12",
  month =        mar # "\slash " # apr,
  year =         "2011",
  CODEN =        "CSENFA",
  DOI =          "http://dx.doi.org/10.1109/MCSE.2011.36",
  ISSN =         "1521-9615 (print), 1558-366X (electronic)",
  ISSN-L =       "1521-9615",
  bibdate =      "Fri Apr 1 22:44:30 2011",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Computing in Science and Engineering",
}

@Article{Parkin:2011:DEL,
  author =       "Tom Parkin",
  title =        "Debugging embedded {Linux} platforms with {DGB} and
                 {Python}",
  journal =      j-LINUX-J,
  volume =       "2011",
  number =       "206",
  pages =        "2:1--2:??",
  month =        jun,
  year =         "2011",
  CODEN =        "LIJOFX",
  ISSN =         "1075-3583 (print), 1938-3827 (electronic)",
  ISSN-L =       "1075-3583",
  bibdate =      "Tue Jun 7 18:47:07 MDT 2011",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://portal.acm.org/",
  acknowledgement = ack-nhfb,
  articleno =    "2",
  fjournal =     "Linux Journal",
}

@Article{Perez:2011:PES,
  author =       "Fernando Perez and Brian E. Granger and John D.
                 Hunter",
  title =        "{Python}: An Ecosystem for Scientific Computing",
  journal =      j-COMPUT-SCI-ENG,
  volume =       "13",
  number =       "2",
  pages =        "13--21",
  month =        mar # "\slash " # apr,
  year =         "2011",
  CODEN =        "CSENFA",
  DOI =          "http://dx.doi.org/10.1109/MCSE.2010.119",
  ISSN =         "1521-9615 (print), 1558-366X (electronic)",
  ISSN-L =       "1521-9615",
  bibdate =      "Fri Apr 1 22:44:30 2011",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "Computing in Science and Engineering",
}

@Article{Anonymous:2012:PSR,
  author =       "Anonymous",
  title =        "{Python} scripts as a replacement for {\tt bash}
                 utility scripts",
  journal =      j-LINUX-J,
  volume =       "2012",
  number =       "223",
  pages =        "1:1--1:??",
  month =        nov,
  year =         "2012",
  CODEN =        "LIJOFX",
  ISSN =         "1075-3583 (print), 1938-3827 (electronic)",
  ISSN-L =       "1075-3583",
  bibdate =      "Tue Dec 11 07:44:23 MST 2012",
  bibsource =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/linux-journal.bib;
                 http://www.math.utah.edu/pub/tex/bib/python.bib",
  abstract =     "Learn how to use Python and existing UNIX tools to
                 improve your productivity in the shell.",
  acknowledgement = ack-nhfb,
  articleno =    "1",
  fjournal =     "Linux Journal",
}

@Article{Autin:2012:UUC,
  author =       "Ludovic Autin and Graham Johnson and Johan Hake and
                 Arthur Olson and Michel Sanner",
  title =        "{uPy}: a Ubiquitous {CG Python API} with
                 Biological-Modeling Applications",
  journal =      j-IEEE-CGA,
  volume =       "32",
  number =       "5",
  pages =        "50--61",
  month =        sep # "\slash " # oct,
  year =         "2012",
  CODEN =        "ICGADZ",
  DOI =          "http://dx.doi.org/10.1109/MCG.2012.93",
  ISSN =         "0272-1716 (print), 1558-1756 (electronic)",
  ISSN-L =       "0272-1716",
  bibdate =      "Mon Oct 22 06:56:23 2012",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/ieeecga.bib;
                 http://www.math.utah.edu/pub/tex/bib/python.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "IEEE Computer Graphics and Applications",
}

@Article{Baldwin:2012:SPG,
  author =       "Doug Baldwin",
  title =        "Special projects grants awarded",
  journal =      j-SIGCSE,
  volume =       "44",
  number =       "3",
  pages =        "6--6",
  month =        jul,
  year =         "2012",
  CODEN =        "SIGSD3",
  DOI =          "http://dx.doi.org/10.1145/2350216.2350222",
  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/python.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigcse2010.bib",
  abstract =     "SIGCSE received 15 Special Projects grant proposals
                 for the May 2012 funding cycle. The Special Projects
                 Committee is pleased to announce that the following
                 four grants have been awarded: Anthony Allevato and
                 Steve Edwards, Virginia Tech, ``Pythy---A Cloud-Based
                 IDE for Novice Python Programmers''
                 (http://pythy.cs.vt.edu/). This project will develop a
                 Web-based environment in which novice programmers can
                 write and run Python programs and access documentation
                 and tutorials. This environment reduces the barriers
                 students often face if they have to install development
                 tools on their own computers.",
  acknowledgement = ack-nhfb,
  fjournal =     "SIGCSE Bulletin (ACM Special Interest Group on
                 Computer Science Education)",
}

@Article{Beazley:2012:TYP,
  author =       "David Beazley",
  title =        "Three Years of {Python 3}",
  journal =      j-LOGIN,
  volume =       "37",
  number =       "1",
  pages =        "??--??",
  month =        feb,
  year =         "2012",
  CODEN =        "LOGNEM",
  ISSN =         "1044-6397",
  ISSN-L =       "1044-6397",
  bibdate =      "Fri Dec 7 10:42:18 MST 2012",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://www.math.utah.edu/pub/tex/bib/usenix2010.bib;
                 https://www.usenix.org/publications/login",
  URL =          "https://www.usenix.org/publications/login/february-2012/three-years-python-3",
  acknowledgement = ack-nhfb,
  fjournal =     ";login: the USENIX Association newsletter",
}

@Article{Bell:2012:PSA,
  author =       "Nathan Bell and Anil N. Hirani",
  title =        "{PyDEC}: Software and Algorithms for Discretization of
                 Exterior Calculus",
  journal =      j-TOMS,
  volume =       "39",
  number =       "1",
  pages =        "3:1--3:??",
  month =        nov,
  year =         "2012",
  CODEN =        "ACMSCU",
  DOI =          "http://dx.doi.org/10.1145/2382585.2382588",
  ISSN =         "0098-3500 (print), 1557-7295 (electronic)",
  ISSN-L =       "0098-3500",
  bibdate =      "Thu Dec 6 07:36:30 MST 2012",
  bibsource =    "http://www.acm.org/pubs/contents/journals/toms/;
                 http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://www.math.utah.edu/pub/tex/bib/toms.bib",
  abstract =     "This article describes the algorithms, features, and
                 implementation of PyDEC, a Python library for
                 computations related to the discretization of exterior
                 calculus. PyDEC facilitates inquiry into both physical
                 problems on manifolds as well as purely topological
                 problems on abstract complexes. We describe efficient
                 algorithms for constructing the operators and objects
                 that arise in discrete exterior calculus, lowest-order
                 finite element exterior calculus, and in related
                 topological problems. Our algorithms are formulated in
                 terms of high-level matrix operations which extend to
                 arbitrary dimension. As a result, our implementations
                 map well to the facilities of numerical libraries such
                 as NumPy and SciPy. The availability of such libraries
                 makes Python suitable for prototyping numerical
                 methods. We demonstrate how PyDEC is used to solve
                 physical and topological problems through several
                 concise examples.",
  acknowledgement = ack-nhfb,
  articleno =    "3",
  fjournal =     "ACM Transactions on Mathematical Software (TOMS)",
}

@Article{Briot:2012:GLAa,
  author =       "Emmanuel Briot",
  title =        "Gem \#105: {Lady Ada} kisses {Python} --- part 1",
  journal =      j-SIGADA-LETTERS,
  volume =       "32",
  number =       "2",
  pages =        "45--46",
  month =        aug,
  year =         "2012",
  CODEN =        "AALEE5",
  DOI =          "http://dx.doi.org/10.1145/2429574.2429587",
  ISSN =         "0736-721X",
  bibdate =      "Wed Jan 30 16:10:15 MST 2013",
  bibsource =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigada.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGADA Ada Letters",
}

@Article{Briot:2012:GLAb,
  author =       "Emmanuel Briot",
  title =        "Gem \#106: {Lady Ada} kisses {Python} --- part 2",
  journal =      j-SIGADA-LETTERS,
  volume =       "32",
  number =       "2",
  pages =        "47--49",
  month =        aug,
  year =         "2012",
  CODEN =        "AALEE5",
  DOI =          "http://dx.doi.org/10.1145/2429574.2429588",
  ISSN =         "0736-721X",
  bibdate =      "Wed Jan 30 16:10:15 MST 2013",
  bibsource =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigada.bib",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGADA Ada Letters",
}

@Article{Castanos:2012:BPE,
  author =       "Jose Castanos and David Edelsohn and Kazuaki Ishizaki
                 and Priya Nagpurkar and Toshio Nakatani and Takeshi
                 Ogasawara and Peng Wu",
  title =        "On the benefits and pitfalls of extending a statically
                 typed language {JIT} compiler for dynamic scripting
                 languages",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "10",
  pages =        "195--212",
  month =        oct,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "http://dx.doi.org/10.1145/2398857.2384631",
  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/python.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Whenever the need to compile a new dynamically typed
                 language arises, an appealing option is to repurpose an
                 existing statically typed language Just-In-Time (JIT)
                 compiler (repurposed JIT compiler). Existing repurposed
                 JIT compilers (RJIT compilers), however, have not yet
                 delivered the hoped-for performance boosts. The
                 performance of JVM languages, for instance, often lags
                 behind standard interpreter implementations. Even more
                 customized solutions that extend the internals of a JIT
                 compiler for the target language compete poorly with
                 those designed specifically for dynamically typed
                 languages. Our own Fiorano JIT compiler is an example
                 of this problem. As a state-of-the-art, RJIT compiler
                 for Python, the Fiorano JIT compiler outperforms two
                 other RJIT compilers (Unladen Swallow and Jython), but
                 still shows a noticeable performance gap compared to
                 PyPy, today's best performing Python JIT compiler. In
                 this paper, we discuss techniques that have proved
                 effective in the Fiorano JIT compiler as well as
                 limitations of our current implementation. More
                 importantly, this work offers the first in-depth look
                 at benefits and limitations of the repurposed JIT
                 compiler approach. We believe the most common pitfall
                 of existing RJIT compilers is not focusing sufficiently
                 on specialization, an abundant optimization opportunity
                 unique to dynamically typed languages. Unfortunately,
                 the lack of specialization cannot be overcome by
                 applying traditional optimizations.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  remark =       "OOPSLA '12 conference proceedings.",
}

@Article{Conti:2012:TMP,
  author =       "Juan Jos{\'e} Conti and Alejandro Russo",
  title =        "A {Taint} Mode for {Python} via a Library",
  journal =      j-LECT-NOTES-COMP-SCI,
  volume =       "7127",
  pages =        "210--222",
  year =         "2012",
  CODEN =        "LNCSD9",
  DOI =          "http://dx.doi.org/10.1007/978-3-642-27937-9_15",
  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/lncs2012b.bib;
                 http://www.math.utah.edu/pub/tex/bib/python.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-642-27937-9_15/",
  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{Darcy:2012:EGP,
  author =       "Jeff Darcy",
  title =        "Extending {GlusterFS} with {Python}",
  journal =      j-LINUX-J,
  volume =       "2012",
  number =       "223",
  pages =        "2:1--2:??",
  month =        nov,
  year =         "2012",
  CODEN =        "LIJOFX",
  ISSN =         "1075-3583 (print), 1938-3827 (electronic)",
  ISSN-L =       "1075-3583",
  bibdate =      "Tue Dec 11 07:44:23 MST 2012",
  bibsource =    "http://portal.acm.org/;
                 http://www.math.utah.edu/pub/tex/bib/linux-journal.bib;
                 http://www.math.utah.edu/pub/tex/bib/python.bib",
  abstract =     "GlusterFS is a distributed filesystem with a strong
                 emphasis on extensibility. Now extensions can be
                 written in Python, bringing significant performance and
                 other improvements within reach of even more
                 programmers.",
  acknowledgement = ack-nhfb,
  articleno =    "2",
  fjournal =     "Linux Journal",
}

@Article{Ettienne:2012:IMA,
  author =       "Mikko Berggren Ettienne and Steen Vester and J{\o}rgen
                 Villadsen",
  title =        "Implementing a Multi-Agent System in {Python} with an
                 Auction-Based Agreement Approach",
  journal =      j-LECT-NOTES-COMP-SCI,
  volume =       "7217",
  pages =        "185--196",
  year =         "2012",
  CODEN =        "LNCSD9",
  DOI =          "http://dx.doi.org/10.1007/978-3-642-31915-0_11",
  ISSN =         "0302-9743 (print), 1611-3349 (electronic)",
  ISSN-L =       "0302-9743",
  bibdate =      "Wed Dec 19 15:17:50 MST 2012",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/lncs2012c.bib;
                 http://www.math.utah.edu/pub/tex/bib/python.bib",
  URL =          "http://link.springer.com/chapter/10.1007/978-3-642-31915-0_11/",
  acknowledgement = ack-nhfb,
  book-DOI =     "http://dx.doi.org/10.1007/978-3-642-31915-0",
  book-URL =     "http://www.springerlink.com/content/978-3-642-31915-0",
  fjournal =     "Lecture Notes in Computer Science",
}

@Article{Gasiorek:2012:OPP,
  author =       "Marcin Ga{\c{s}}iorek and Daniel Simson",
  title =        "One-peak posets with positive quadratic {Tits} form,
                 their mesh translation quivers of roots, and
                 programming in {Maple} and {Python}",
  journal =      j-LINEAR-ALGEBRA-APPL,
  volume =       "436",
  number =       "7",
  pages =        "2240--2272",
  day =          "1",
  month =        apr,
  year =         "2012",
  CODEN =        "LAAPAW",
  DOI =          "http://dx.doi.org/10.1016/j.laa.2011.10.045",
  ISSN =         "0024-3795 (print), 1873-1856 (electronic)",
  ISSN-L =       "0024-3795",
  bibdate =      "Tue Feb 7 16:11:50 MST 2012",
  bibsource =    "http://www.math.utah.edu/pub/tex/bib/linala2010.bib;
                 http://www.math.utah.edu/pub/tex/bib/maple-extract.bib;
                 http://www.math.utah.edu/pub/tex/bib/python.bib;
                 http://www.sciencedirect.com/science/journal/00243795",
  URL =          "http://www.sciencedirect.com/science/article/pii/S0024379511007555",
  acknowledgement = ack-nhfb,
  fjournal =     "Linear Algebra and its Applications",
}

@Article{Hirschfeld:2012:EUC,
  author =       "Robert Hirschfeld and Michael Perscheid and Michael
                 Haupt",
  title =        "Explicit use-case representation in object-oriented
                 programming languages",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "2",
  pages =        "51--60",
  month =        feb,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "http://dx.doi.org/10.1145/2168696.2047856",
  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/python.bib;
                 http://www.math.utah.edu/pub/tex/bib/sigplan2010.bib",
  abstract =     "Use-cases are considered an integral part of most
                 contemporary development processes since they describe
                 a software system's expected behavior from the
                 perspective of its prospective users. However, the
                 presence of and traceability to use-cases is
                 increasingly lost in later more code-centric
                 development activities. Use-cases, being
                 well-encapsulated at the level of requirements
                 descriptions, eventually lead to crosscutting concerns
                 in system design and source code. Tracing which parts
                 of the system contribute to which use-cases is
                 therefore hard and so limits understandability. In this
                 paper, we propose an approach to making use-cases
                 first-class entities in both the programming language
                 and the runtime environment. Having use-cases present
                 in the code and the running system will allow
                 developers, maintainers, and operators to easily
                 associate their units of work with what matters to the
                 users. We suggest the combination of use-cases,
                 acceptance tests, and dynamic analysis to automatically
                 associate source code with use-cases. We present
                 UseCasePy, an implementation of our approach to
                 use-case-centered development in Python, and its
                 application to the Django Web framework.",
  acknowledgement = ack-nhfb,
  fjournal =     "ACM SIGPLAN Notices",
  remark =       "DSL '11 conference proceedings.",
}

@Article{Homescu:2012:HTJ,
  author =       "Andrei Homescu and Alex Suhan",
  title =        "{HappyJIT}: a tracing {JIT} compiler for {PHP}",
  journal =      j-SIGPLAN,
  volume =       "47",
  number =       "2",
  pages =        "25--36",
  month =        feb,
  year =         "2012",
  CODEN =        "SINODQ",
  DOI =          "http://dx.doi.org/10.1145/2168696.2047854",
  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/python.bib;
                 http://www

license: MIT

license_type: permissive

branch_name: refs/heads/master

extension: bib