[pypy-svn] rev 1752 - pypy/trunk/doc

[sanxiyn at codespeak.net]

Author: sanxiyn
Date: Sun Oct 12 09:15:07 2003
New Revision: 1752

Modified:
   pypy/trunk/doc/oscon2003-paper.txt
Log:
typos


Modified: pypy/trunk/doc/oscon2003-paper.txt
==============================================================================
--- pypy/trunk/doc/oscon2003-paper.txt	(original)
+++ pypy/trunk/doc/oscon2003-paper.txt	Sun Oct 12 09:15:07 2003
@@ -77,7 +77,7 @@
 
 In a Python-like language, a running interpreter has three main parts:
   
-  * the main loop, which suffles data around and calls the operations defined in the object library according to the bytecode.
+  * the main loop, which shuffles data around and calls the operations defined in the object library according to the bytecode.
   * the compiler, which represents the static optimization of the source code into an intermediate format, the bytecode;  and
   * the object library, implementing the various types of objects and their semantics;
 
@@ -146,11 +146,11 @@
 the time needed to communicate between the various calculators, you
 will benefit by adding more CPUS.  Thus PyPy will provide you with an
 alternative way to write a Cluster.  (`The Beowulf Cluster`_ is
-probaby the most famous of Cluster architectures).  Right now 'network
+probably the most famous of Cluster architectures).  Right now 'network
 computing' is in its infancy.  We don't know how to take advantage of
 the resources we have.  Ideally, one could begin a computation on a
 small device, say a mobile phone, and have the interpreter notice that
-the device is underpowered for such a computation and transparantly
+the device is underpowered for such a computation and transparently
 forward the computation to a machine with more computational power.
 You could have *peak computing machines* in the same way that
 electrical utilities have plants which are expensive to
@@ -164,7 +164,7 @@
 Consider the question: *What is the best way to implement a dict*?
 
 How one answers depends on how much data one intends to store.
-If the dict is never expcted to have more than a half dozen items, a
+If the dict is never expected to have more than a half dozen items, a
 really fast list may be best.  Larger dicts might best be implemented
 as hashes.  For storing enormous amounts of data, a binary tree
 might be just what you desire.  In principle, there is
@@ -223,7 +223,7 @@
 Runtime Adaptation of C-Libraries and System-Calls
 ++++++++++++++++++++++++++++++++++++++++++++++++++
 Python is already widely used for integrating and driving C-libraries
-(for numerical compuatation, 3D-modeling etc.).  We dream
+(for numerical computation, 3D-modeling etc.).  We dream
 of introducing runtime mechanisms that allow PyPy to directly setup and
 execute "native" calls on a machine.  For this to work we need
 "trampolin" (assembler-) functions that build a C-like stackframe
@@ -270,8 +270,8 @@
 You could load your existing modules with the Object Space they were
 developed for while immediately using new features in new code that
 you develop.  It would be up to the PyPy interpreter to see that these
-Object Spaces communicate with each other transparantly.  Only modules
-that would particularily benefit from having the new features, would
+Object Spaces communicate with each other transparently.  Only modules
+that would particularly benefit from having the new features, would
 be modified.  The rest could sleep peacefully, unchanged.
 
 This leads to:
@@ -379,7 +379,7 @@
 
  print (reduce(lambda x, y: x+y, [t[2] for t in slips], 0))/900
 
-Pypy said: 603 SEK, or appoximately 75 USD.   Don't believe people who
+Pypy said: 603 SEK, or approximately 75 USD.   Don't believe people who
 tell you that Sprints are too expensive to hold. 
 
 The Annotation Object Space
@@ -425,7 +425,7 @@
 The eventual hope is to run all of the code that implements PyPy's
 interpreter and the standard object space with the annotation object
 space and gain sufficient knowledge of the values involved to generate
-efficent code (in C, Pyrex_, O'Caml, Java or whatever) to do the same
+efficient code (in C, Pyrex_, O'Caml, Java or whatever) to do the same
 job.
 
 If you're wondering how we expect to get a speed up of 20000 times by
@@ -434,7 +434,7 @@
 main reason for the standard object space's current slowness is the
 computation of which code to execute each time a multimethod is
 called.  The knowledge gathered by the Annontation Object Space should
-be sufficient to remove or at lesat substantially reduce this computation 
+be sufficient to remove or at least substantially reduce this computation 
 for most of the call sites.
 
 Current plans are to use the information gathered from the Annotation Object 
@@ -448,7 +448,7 @@
 inheritance and the Method Resolution Order are defined, and where
 attribute look-ups are done.
 
-Instances of user-defined types are implementated as W_UserObjects. A
+Instances of user-defined types are implemented as W_UserObjects. A
 user-defined type can inherit from built-in types (maybe more than
 one, although this is incompatible with CPython). The W_UserObject
 delegator converts the object into any of these "parent objects" if
@@ -581,7 +581,7 @@
 .. _roundup: http://roundup.sourceforge.net/
 .. _moinmoin: http://moin.sourceforge.net/
 
-The members of the PyPy team are especiallly grateful to RyanAir_, without
+The members of the PyPy team are especially grateful to RyanAir_, without
 which holding Sprints would be prohibitively expensive, freenode.net_
 which lets us communicate with each other on the #pypy channel, and the
 Subversion_ development team, without whom restructuring the entire universe
@@ -592,9 +592,9 @@
 .. _Subversion: http://subversion.tigris.org/
 
 
-.. [#] The PyPy homespage: http://www.codespeak.net/pypy/
+.. [#] The PyPy homepage: http://www.codespeak.net/pypy/
 .. [#] See for instance, Scheme48's PreScheme
-.. [#] The Squeak homespage: http://www.squeak.org/
+.. [#] The Squeak homepage: http://www.squeak.org/
 .. [#] See *Back to the Future The Story of Squeak, A Practical 
        Smalltalk Written in Itself* ftp://st.cs.uiuc.edu/Smalltalk/Squeak/docs/OOPSLA.Squeak.html
 .. [#] CPython is what we call the commonly available Python_ which you