[pypy-svn] r63847 - pypy/extradoc/talk/icooolps2009

cfbolz at codespeak.net cfbolz at codespeak.net
Wed Apr 8 17:36:29 CEST 2009


Author: cfbolz
Date: Wed Apr  8 17:36:26 2009
New Revision: 63847

Modified:
   pypy/extradoc/talk/icooolps2009/paper.bib
Log:
be consistent about capitalization in the references


Modified: pypy/extradoc/talk/icooolps2009/paper.bib
==============================================================================
--- pypy/extradoc/talk/icooolps2009/paper.bib	(original)
+++ pypy/extradoc/talk/icooolps2009/paper.bib	Wed Apr  8 17:36:26 2009
@@ -1,12 +1,12 @@
 
 @inproceedings{chang_tracing_2009,
 	address = {Washington, {DC,} {USA}},
-	title = {Tracing for web 3.0: trace compilation for the next generation web applications},
+	title = {Tracing for Web 3.0: Trace Compilation for the Next Generation Web Applications},
 	isbn = {978-1-60558-375-4},
 	url = {http://portal.acm.org/citation.cfm?id=1508293.1508304},
 	doi = {10.1145/1508293.1508304},
 	abstract = {Today's web applications are pushing the limits of modern web browsers. The emergence of the browser as the platform of choice for rich client-side applications has shifted the use of in-browser {JavaScript} from small scripting programs to large computationally intensive application logic. For many web applications, {JavaScript} performance has become one of the bottlenecks preventing the development of even more interactive client side applications. While traditional just-in-time compilation is successful for statically typed virtual machine based languages like Java, compiling {JavaScript} turns out to be a challenging task. Many {JavaScript} programs and scripts are short-lived, and users expect a responsive browser during page loading. This leaves little time for compilation of {JavaScript} to generate machine code.},
-	booktitle = {Proceedings of the 2009 {ACM} {SIGPLAN/SIGOPS} international conference on Virtual execution environments},
+	booktitle = {Proceedings of the 2009 {ACM} {SIGPLAN/SIGOPS} International Conference on Virtual Execution Environments},
 	publisher = {{ACM}},
 	author = {Mason Chang and Edwin Smith and Rick Reitmaier and Michael Bebenita and Andreas Gal and Christian Wimmer and Brendan Eich and Michael Franz},
 	year = {2009},
@@ -24,12 +24,12 @@
 
 @inproceedings{ancona_rpython:step_2007,
 	address = {Montreal, Quebec, Canada},
-	title = {{RPython:} a step towards reconciling dynamically and statically typed {OO} languages},
+	title = {{RPython:} A Step towards Reconciling Dynamically and Statically Typed {OO} Languages},
 	isbn = {978-1-59593-868-8},
 	url = {http://portal.acm.org/citation.cfm?id=1297091},
 	doi = {10.1145/1297081.1297091},
 	abstract = {Although the C-based interpreter of Python is reasonably fast, implementations on the {CLI} or the {JVM} platforms offers some advantages in terms of robustness and interoperability. Unfortunately, because the {CLI} and {JVM} are primarily designed to execute statically typed, object-oriented languages, most dynamic language implementations cannot use the native bytecodes for common operations like method calls and exception handling; as a result, they are not able to take full advantage of the power offered by the {CLI} and {JVM.}},
-	booktitle = {Proceedings of the 2007 symposium on Dynamic languages},
+	booktitle = {Proceedings of the 2007 Symposium on Dynamic languages},
 	publisher = {{ACM}},
 	author = {Davide Ancona and Massimo Ancona and Antonio Cuni and Nicholas D. Matsakis},
 	year = {2007},
@@ -48,7 +48,7 @@
 },
 
 @book{jones_partial_1993,
-	title = {Partial evaluation and automatic program generation},
+	title = {Partial evaluation and Automatic Program Generation},
 	isbn = {0-13-020249-5},
 	url = {http://portal.acm.org/citation.cfm?id=153676},
 	abstract = {This book is out of print. For copies, Please refer to the following online page},
@@ -60,12 +60,12 @@
 
 @inproceedings{rigo_pypys_2006,
 	address = {Portland, Oregon, {USA}},
-	title = {{PyPy's} approach to virtual machine construction},
+	title = {{PyPy's} Approach to Virtual Machine Construction},
 	isbn = {{1-59593-491-X}},
 	url = {http://portal.acm.org/citation.cfm?id=1176753},
 	doi = {10.1145/1176617.1176753},
 	abstract = {The {PyPy} project seeks to prove both on a research and a practical level the feasibility of constructing a virtual machine {(VM)} for a dynamic language in a dynamic language - in this case, Python. The aim is to translate (i.e. compile) the {VM} to arbitrary target environments, ranging in level from {C/Posix} to {Smalltalk/Squeak} via Java and {CLI/.NET,} while still being of reasonable efficiency within these {environments.A} key tool to achieve this goal is the systematic reuse of the Python language as a system programming language at various levels of our architecture and translation process. For each level, we design a corresponding type system and apply a generic type inference engine - for example, the garbage collector is written in a style that manipulates simulated pointer and address objects, and when translated to C these operations become C-level pointer and address instructions.},
-	booktitle = {Companion to the 21st {ACM} {SIGPLAN} conference on Object-oriented programming systems, languages, and applications},
+	booktitle = {Companion to the 21st {ACM} {SIGPLAN} Conference on Object-Oriented Programming Systems, Languages, and Applications},
 	publisher = {{ACM}},
 	author = {Armin Rigo and Samuele Pedroni},
 	year = {2006},
@@ -92,7 +92,7 @@
 },
 
 @inproceedings{andreas_gal_trace-based_2009,
-	title = {Trace-based {Just-in-Time} Type Specialization for Dynamic Languages },
+	title = {Trace-based {Just-in-Time} Type Specialization for Dynamic Languages},
 	booktitle = {{PLDI}},
 	author = {Andreas Gal and Brendan Eich and Mike Shaver and David Anderson and Blake Kaplan and Graydon Hoare and David Mandelin and Boris Zbarsky and Jason Orendorff and Michael Bebenita and Mason Chang and Michael Franz and Edwin Smith and Rick Reitmaier and Mohammad Haghighat},
 	year = {2009},
@@ -135,7 +135,7 @@
 },
 
 @article{grant_dyc:expressive_2000,
-	title = {{DyC:} an expressive annotation-directed dynamic compiler for C},
+	title = {{DyC:} An Expressive Annotation-Directed Dynamic Compiler for C},
 	volume = {248},
 	url = {http://citeseer.ist.psu.edu/grant97dyc.html},
 	number = {1--2},
@@ -153,7 +153,7 @@
 },
 
 @article{bala_dynamo:transparent_2000,
-	title = {Dynamo: a transparent dynamic optimization system},
+	title = {Dynamo: a Transparent Dynamic Optimization System},
 	volume = {35},
 	url = {http://citeseer.ist.psu.edu/bala00dynamo.html},
 	number = {5},
@@ -187,12 +187,12 @@
 
 @inproceedings{gal_hotpathvm:effective_2006,
 	address = {Ottawa, Ontario, Canada},
-	title = {{HotpathVM:} an effective {JIT} compiler for resource-constrained devices},
+	title = {{HotpathVM:} An Effective {JIT} Compiler for Resource-Constrained Devices},
 	isbn = {1-59593-332-6},
 	url = {http://portal.acm.org/citation.cfm?doid=1134760.1134780},
 	doi = {10.1145/1134760.1134780},
 	abstract = {We present a just-in-time compiler for a Java {VM} that is small enough to fit on resource-constrained devices, yet is surprisingly effective. Our system dynamically identifies traces of frequently executed bytecode instructions (which may span several basic blocks across several methods) and compiles them via Static Single Assignment {(SSA)} construction. Our novel use of {SSA} form in this context allows to hoist instructions across trace side-exits without necessitating expensive compensation code in off-trace paths. The overall memory consumption (code and data) of our system is only 150 {kBytes,} yet benchmarks show a speedup that in some cases rivals heavy-weight just-in-time compilers.},
-	booktitle = {Proceedings of the 2nd international conference on Virtual execution environments},
+	booktitle = {Proceedings of the 2nd International Conference on Virtual Execution Environments},
 	publisher = {{ACM}},
 	author = {Andreas Gal and Christian W. Probst and Michael Franz},
 	year = {2006},
@@ -201,7 +201,7 @@
 
 @inproceedings{hlzle_optimizing_1994,
 	address = {Orlando, Florida, United States},
-	title = {Optimizing dynamically-dispatched calls with run-time type feedback},
+	title = {Optimizing Dynamically-Dispatched Calls with Run-Time Type Feedback},
 	isbn = {{0-89791-662-X}},
 	url = {http://portal.acm.org/citation.cfm?id=178243.178478},
 	doi = {10.1145/178243.178478},
@@ -214,7 +214,7 @@
 },
 
 @article{consel_uniform_1996,
-	title = {A uniform approach for compile-time and run-time specialization},
+	title = {A Uniform Approach for Compile-Time and Run-Time Specialization},
 	url = {http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.103.248},
 	doi = {10.1.1.103.248},
 	journal = {Dagstuhl Seminar on Partial Evaluation},
@@ -236,12 +236,12 @@
 },
 
 @inproceedings{carl_friedrich_bolz_to_2007,
-	title = {How to not write a Virtual Machine},
+	title = {How to \emph{not} Write a Virtual Machine},
 	abstract = {Typical modern dynamic languages have a growing number of implementations. We explore the reasons for this situation, and the limitations it imposes on open source or academic communities that lack the resources to fine-tune and maintain them all. It is sometimes proposed that implementing dynamic languages on top of a standardized general-purpose object-oriented virtual machine (like Java or {.NET)} would help reduce this burden. We propose a complementary alternative to writing custom virtual machine {(VMs)} by hand, validated by the {PyPy} project: flexibly generating {VMs} from a high-level "specification",
 inserting features and low-level details automatically – including good just-in-time compilers tuned to the dynamic language at hand.
 We believe this to be ultimately a better investment of efforts than the development of more and more advanced general-purpose object
 oriented {VMs.} In this paper we compare these two approaches in detail.},
-	booktitle = {Proceedings of 3rd Workshop on Dynamic Languages and Applications {(DYLA} 2007)},
+	booktitle = {Proceedings of the 3rd Workshop on Dynamic Languages and Applications {(DYLA} 2007)},
 	author = {Carl Friedrich Bolz and Armin Rigo},
 	year = {2007}
 },
@@ -259,7 +259,7 @@
 
 @inproceedings{rigo_representation-based_2004,
 	address = {Verona, Italy},
-	title = {Representation-based just-in-time specialization and the psyco prototype for python},
+	title = {Representation-Based Just-in-Time Specialization and the Psyco Prototype for Python},
 	isbn = {1-58113-835-0},
 	url = {http://portal.acm.org/citation.cfm?id=1014010},
 	doi = {10.1145/1014007.1014010},
@@ -273,12 +273,12 @@
 
 @inproceedings{sullivan_dynamic_2003,
 	address = {San Diego, California},
-	title = {Dynamic native optimization of interpreters},
+	title = {Dynamic Native Optimization of Interpreters},
 	isbn = {1-58113-655-2},
 	url = {http://portal.acm.org/citation.cfm?id=858570.858576},
 	doi = {10.1145/858570.858576},
 	abstract = {For domain specific languages, "scripting languages", dynamic languages, and for virtual machine-based languages, the most straightforward implementation strategy is to write an interpreter. A simple interpreter consists of a loop that fetches the next bytecode, dispatches to the routine handling that bytecode, then loops. There are many ways to improve upon this simple mechanism, but as long as the execution of the program is driven by a representation of the program other than as a stream of native instructions, there will be some "interpretive {overhead".There} is a long history of approaches to removing interpretive overhead from programming language implementations. In practice, what often happens is that, once an interpreted language becomes popular, pressure builds to improve performance until eventually a project is undertaken to implement a native Just In Time {(JIT)} compiler for the language. Implementing a {JIT} is usually a large effort, affects a significant part of the existing language implementation, and adds a significant amount of code and complexity to the overall code {base.In} this paper, we present an innovative approach that dynamically removes much of the interpreted overhead from language implementations, with minimal instrumentation of the original interpreter. While it does not give the performance improvements of hand-crafted native compilers, our system provides an appealing point on the language implementation spectrum.},
-	booktitle = {Proceedings of the 2003 workshop on Interpreters, virtual machines and emulators},
+	booktitle = {Proceedings of the 2003 Workshop on Interpreters, Virtual Machines and Emulators},
 	publisher = {{ACM}},
 	author = {Gregory T. Sullivan and Derek L. Bruening and Iris Baron and Timothy Garnett and Saman Amarasinghe},
 	year = {2003},
@@ -303,12 +303,12 @@
 
 @inproceedings{consel_general_1996,
 	address = {St. Petersburg Beach, Florida, United States},
-	title = {A general approach for run-time specialization and its application to C},
+	title = {A General Approach for Run-Time Specialization and its Application to {C}},
 	isbn = {0-89791-769-3},
 	url = {http://portal.acm.org/citation.cfm?id=237767},
 	doi = {10.1145/237721.237767},
 	abstract = {Note: {OCR} errors may be found in this Reference List extracted from the full text article. {ACM} has opted to expose the complete List rather than only correct and linked references.},
-	booktitle = {Proceedings of the 23rd {ACM} {SIGPLAN-SIGACT} symposium on Principles of Programming Languages},
+	booktitle = {Proceedings of the 23rd {ACM} {SIGPLAN-SIGACT} Symposium on Principles of Programming Languages},
 	publisher = {{ACM}},
 	author = {Charles Consel and François Noël},
 	year = {1996},



More information about the Pypy-commit mailing list