diff --git a/docs/DeveloperPolicy.html b/docs/DeveloperPolicy.html
index f3b2c70..d2046e2 100644
--- a/docs/DeveloperPolicy.html
+++ b/docs/DeveloperPolicy.html
@@ -34,6 +34,7 @@
   </ol></li>
   <li><a href="#candl">Copyright and License</a>
   <ol>
+    <li><a href="#attribution">Attribution</a></li>
     <li><a href="#copyright">Copyright</a></li>
     <li><a href="#license">License</a></li>
     <li><a href="#devagree">Developer Agreements</a></li>
@@ -184,11 +185,10 @@
     <li>Code must compile cleanly (no errors, no warnings) on at least one 
     platform.</li>
     <li>Code must pass the deja gnu (llvm/test) test suite.</li>
-    <li>
   </ol>
   <p>Additionally, the committer is responsible for all of the following items.
-  It is considered significantly preferable for all of these items to be 
-  accounted for <i>before</i> the code is submitted for review or committed.</p>
+  The developer should ensure each of the following before the code is 
+  submitted for review or committed.</p>
   <ol>
     <li>Code must compile cleanly on all platforms.</li>
     <li>Code must pass the <tt>llvm-test</tt> test suite including 
@@ -212,16 +212,17 @@
     selected (see the <a href="TestingGuide.html">Testing Guide</a> for 
     details).</li>
     <li>Test cases should be written in LLVM assembly language unless the
-    feature or regression being tested requires another language.</li>
-    <li>Test cases, especially for regressions, should be as reduced as 
-    possible, preferably by 
-    <a href="CommandGuide/html/bugpoint.html">bugpoint</a>.  It is unacceptable 
+    feature or regression being tested requires another language (e.g. the
+    but being fixed or feature being implemented is in the lvm-gcc C++
+    front-end).</li>
+    <li>Test cases, especially for regressions, should be much as reduced as 
+    possible, by <a href="CommandGuide/html/bugpoint.html">bugpoint</a> or
+    manually. It is unacceptable 
     to place an entire failing program into <tt>llvm/test</tt> as this creates
     a <i>time-to-test</i> burden on all developers. Keep them short!</li>
     <li>More extensive test cases (applications, benchmarks, etc.) should be 
-    added to the <tt>llvm-test</tt> test suite, after approval from the
-    Oversight Group. This test suite is for coverage not features or 
-    regressions.</li>
+    added to the <tt>llvm-test</tt> test suite.  This test suite is for 
+    coverage not features or regressions.</li>
   </ol>
 </div>
 
@@ -239,9 +240,9 @@
   <ol>
     <li>Patches must be made against the CVS HEAD (main development trunk), 
     not a branch.</li>
-    <li>Patches must be made with this cvs command:<pre>
+    <li>Patches should be made with this command:<pre>
     cvs diff -Ntdup -5</pre> or with the utility <tt>utils/mkpatch</tt>.</li>
-    <li>Patches must not include differences in generated code such as the
+    <li>Patches should not include differences in generated code such as the
     code generated by <tt>flex</tt>, <tt>bison</tt> or <tt>tblgen</tt>. The
     <tt>utils/mkpatch</tt> utility takes care of this for you.</li>
   </ol>
@@ -264,9 +265,9 @@
   <p>When a patch is ready to be submitted, these policies apply:</p>
   <ol>
     <li>Patches should be submitted immediately after they are generated. Stale
-    patches are unlikely to apply correctly and could be rejected simply due to
-    age.</li>
-    <li>Patches must be submitted by e-mail to the 
+    patches may not apply correctly if the underlying code changes between the
+    time the patch was created and the time it is applied.</li>
+    <li>Patches should be submitted by e-mail to the 
     <a href="http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits">
       llvm-commits</a> list.</li>
   </ol>
@@ -279,8 +280,9 @@
   <ol>
     <li>The patch is subject to review by anyone on the llvm-commits email list.
     </li>
-    <li>Any changes recommended by the reviewer must be made by the submitter
-    of the patch and the patch re-submitted.</li>
+    <li>Changes recommended by a reviewer should be incorporated into your
+    patch or you should explain why the reviewer is incorrect. This patch
+    iterates until there are no more review comments.</li>
     <li>If the submitter believes the review comment is in error, a response to
     the  <a href="http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits">
       llvm-commits</a> list should be made explaining why the recommendation 
@@ -310,14 +312,15 @@
   <ol>
     <li>Commit access is not granted to anyone unless they specifically ask for
     it.</li>
-    <li>Requests for commit access must be sent to the LLVM Oversight Group at
-    <a href="mailto:oversight@llvm.org">oversight@llvm.org</a>.</li>
+    <li>Requests for commit access must be sent to the 
+    <a href="mailto:llvm-oversight@cs.uiuc.edu">LLVM Oversight Group</a>.</li>
     <li>Granting commit access is at the sole discretion of the LLVM Oversight
     Group.</li>
-    <li>Submitting patches to LLVM via the patch policy above will greatly
-    increase the chance that your request for commit access is granted.</li>
-    <li>Getting to know the members of the LLVM community (email, IRC, in person
-    contact, etc.) will also increase your chances.</li>
+  </ol>
+  <p>Submitting patches to LLVM via the patch policy above will greatly 
+  increase the chance that your request for commit access is granted. Getting 
+  to know the members of the LLVM community (email, IRC, in person contact, 
+  etc.) will also increase your chances.</p>
   </ol>
 </div>
 
@@ -328,8 +331,13 @@
   apply:</p>
   <ol>
     <li>You are granted <i>commit-after-approval</i> to all parts of LLVM.
-    To get approval, submit a patch to llvm-commits per the patch policies 
-    above.  When approved you may commit it yourself.</li>
+    To get approval, submit a patch to 
+    <a href="http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits">llvm-commits</a>
+    per the patch policies above.  When approved you may commit it 
+    yourself.</li>
+    <li>You are allowed to commit patches without approval which you think are
+    obvious. This is clearly a subjective decision. We simply expect you to
+    use good judgement.</li>
     <li>You are granted <i>commit-without-approval</i> to those portions of LLVM
     that you own (contributed) or maintain (have been assigned responsibility 
     for), with the proviso that such commits must not break the build. This is
@@ -340,8 +348,7 @@
     making progress. The developers is welcome to re-commit the change after 
     the problem has been fixed.</li>
     <li>Multiple violations of these policies or a single egregious violation
-    may cause commit access to be revoked, at the sole discretion of the
-    LLVM Oversight Group.</li>
+    may cause commit access to be revoked.</li>
   </ol>
 </div>
 
@@ -363,7 +370,7 @@
 </div>
 
 <!-- _______________________________________________________________________ -->
-<div class="doc_subsection"><a name="copyright">Attribution</a></div>
+<div class="doc_subsection"><a name="attribution">Attribution</a></div>
 <div class="doc_text">
   <p>The LLVM project believes in correct attribution of contributions to 
   their contributors, as follows:</p>
@@ -406,8 +413,8 @@
 <div class="doc_subsection"><a name="license">License</a></div>
 <div class="doc_text">
   <p>LLVM licensing decisions will be made by the LLVM Oversight Group. Any
-  issues, comments or suggestions with the licensing should be sent to 
-  <a href="mailto:oversight@llvm.org">oversight@llvm.org</a>.</p>
+  issues, comments or suggestions with the licensing should be sent to the
+  <a href="mailto:llvm-oversight@cs.uiuc.edu">LLVM Oversight Group</a>.</p>
   <p>The LLVM Oversight Group intends to keep LLVM perpetually open source 
   and to use liberal open source licenses. The current license is the 
   University of Illinois Open Source License (see LICENSE.TXT), which boils
@@ -459,7 +466,8 @@
   src="http://jigsaw.w3.org/css-validator/images/vcss" alt="Valid CSS!"></a>
   <a href="http://validator.w3.org/check/referer"><img
   src="http://www.w3.org/Icons/valid-html401" alt="Valid HTML 4.01!" /></a>
-  Written By: <a href="mailto:oversight@llvm.org">LLVM Oversight Group</a><br>
+  Written By: the 
+  <a href="mailto:llvm-oversight@cs.uiuc.edu">LLVM Oversight Group</a><br>
   <a href="http://llvm.org">The LLVM Compiler Infrastructure</a><br>
   Last modified: $Date$
 </address>
