Commits

Shlomi Fish committed 6d40dac

Add more.

  • Participants
  • Parent commits e13319b

Comments (0)

Files changed (5)

File bin/spell-checker-iface.sh

 #!/bin/bash
 find dest/t2-homepage/ -name '*.html' -or -name '*.xhtml' |
     ( LC_ALL=C sort  ) |
-    perl -lne 'print if 1..m#philosophy/computers/open-source/index#' |
+    perl -lne 'print if 1..m#philosophy/computers/optimizing-code-for-speed/index#' |
     grep -vP 'guide2ee/undergrad' |
     grep -vP '(?:humour/TheEnemy/(?:The-Enemy-(?:English-)?rev|TheEnemy))' |
     grep -vP '(?:humour/by-others/(?:English-is-a-Crazy-Language|darien|hitchhiker|how-many-newsgroup-readers|oded-c|s-stands-for-simple|technion-bit-1|top-12-things-likely|was-the-death-star-attack|grad-student-jokes-from-jnoakes))' |
     grep -vP 'humour/humanity/ongoing-text-hebrew' |
     grep -vP 'lecture/Lambda-Calculus/slides/shriram\.scm' |
     grep -vP 'dest/t2-homepage/philosophy/computers/high-quality-software/what-makes-software-high-quality' |
+    grep -vP 'dest/t2-homepage/philosophy/computers/open-source/linus-torvalds-bus-factor/index' |
     xargs perl bin/html-check-spelling-xmlp.pl |
     grep ':'
     # perl -lne 'print if /MathVentures\/3d.*\.xhtml/' |

File lib/docbook/4/xml/perfect-it-workplace.xml

                     Various technologies and
                     <ulink url="http://www.joelonsoftware.com/articles/Platforms.html">development
                         platforms</ulink>, vary in their power and cost. As
-                    opposed to the possible mis-conception of "If you want
+                    opposed to the possible misconception of "If you want
                     something good, you'll have to pay more.", often cheaper,
                     or even gratis (or open-source) solutions are more
                     powerful (not to mention more reliable and faster) than

File lib/htmls/from-mediawiki/orig/Optimizing_Code_for_Speed-rev1.html

 <p>This document will focus on optimizing code to run faster. However, as you will see later, doing this may involve having to optimize the code in a different aspect. Furthermore, often when programmers are trying to optimize one aspect of a program, they are doing so in order to increase speed.</p>
 <p><a name="In_which_programs_is_optimization_required.3F" id="In_which_programs_is_optimization_required.3F"></a></p>
 <h3><span class="editsection">[<a href="/w/index.php?title=Optimizing_Code_for_Speed&amp;action=edit&amp;section=3" title="Edit section: In which programs is optimization required?">edit</a>]</span> <span class="mw-headline">In which programs is optimization required?</span></h3>
-<p>There are several type of programs in which optimization is required. One type of them is <a href="http://en.wikipedia.org/wiki/Real-time_computing" class="extiw" title="wikipedia:Real-time computing">real time programs</a>. Despite common mis-conception, these are not necessarily programs that need to be very fast. Instead real time programs are programs that must respond to certain events within a certain time limit that was dedicated to the event. So for example, if the user presses a keyboard key while inside a word processor window, it should display the character relatively promptly. A 5 seconds delay will be unacceptable and as such a word processor is a kind of application that has some real-time constraints.</p>
+<p>There are several type of programs in which optimization is required. One type of them is <a href="http://en.wikipedia.org/wiki/Real-time_computing" class="extiw" title="wikipedia:Real-time computing">real time programs</a>. Despite common misconception, these are not necessarily programs that need to be very fast. Instead real time programs are programs that must respond to certain events within a certain time limit that was dedicated to the event. So for example, if the user presses a keyboard key while inside a word processor window, it should display the character relatively promptly. A 5 seconds delay will be unacceptable and as such a word processor is a kind of application that has some real-time constraints.</p>
 <p>Some parts of real-time systems may need optimization. However, once the time falls below the required delay, no other optimization is necessary. (At least not until testing proves it is again exceeding the limit.)</p>
 <p>Other programs that require optimization are programs that cannot be fast enough. Examples for such programs are Artificial Intelligence programs, games, multimedia programs, virtual machines and interpreters for programming languages, or any type of publicly available library or module whose use "in the wild" may necessitate it to be very fast.</p>
 <p>And naturally another type of programs are programs that are too slow or perceived to be too slow. While programs of some problem domains are very slow due to the complexity of the calculations involved, that is usually not the case, and nothing prevents a program from being fast. Such programs that are considered too slow should be optimized to make them run faster.</p>
 <h2><span class="editsection">[<a href="/w/index.php?title=Optimizing_Code_for_Speed&amp;action=edit&amp;section=8" title="Edit section: Order of Complexity Optimizations">edit</a>]</span> <span class="mw-headline">Order of Complexity Optimizations</span></h2>
 <p><a name="What_is_order_of_complexity.3F" id="What_is_order_of_complexity.3F"></a></p>
 <h3><span class="editsection">[<a href="/w/index.php?title=Optimizing_Code_for_Speed&amp;action=edit&amp;section=9" title="Edit section: What is order of complexity?">edit</a>]</span> <span class="mw-headline">What is order of complexity?</span></h3>
-<p>Generally, an algorithm has an <a href="http://en.wikipedia.org/wiki/Computational_complexitytheory" class="extiw" title="wikipedia:Computational complexitytheory">asymptotic comptutational complexity</a>. Assuming the input is of size N, we can say that the algorithm will finish at O(N), O(N^2), O(N^3), O(N*log(N)) etc. This means that it is a certain mathematical expression of the size of the input, and the algorithm finishes between two factors of it.</p>
+<p>Generally, an algorithm has an <a href="http://en.wikipedia.org/wiki/Computational_complexitytheory" class="extiw" title="wikipedia:Computational complexitytheory">asymptotic computational complexity</a>. Assuming the input is of size N, we can say that the algorithm will finish at O(N), O(N^2), O(N^3), O(N*log(N)) etc. This means that it is a certain mathematical expression of the size of the input, and the algorithm finishes between two factors of it.</p>
 <p>Generally, the smaller the order of complexity of the program's underlying algorithm, the faster the it will run and the better it will scale as the input gets larger. Thus, we should often seek more efficient algorithms in order to reduce the order of complexity.</p>
 <p><a name="Some_examples_for_reducing_Order_of_Complexity" id="Some_examples_for_reducing_Order_of_Complexity"></a></p>
 <h3><span class="editsection">[<a href="/w/index.php?title=Optimizing_Code_for_Speed&amp;action=edit&amp;section=10" title="Edit section: Some examples for reducing Order of Complexity">edit</a>]</span> <span class="mw-headline">Some examples for reducing Order of Complexity</span></h3>
   .
 </pre>
 <p>And so forth, then the strcat calls will keep starting from the beginning of the string and seek the (increasing) end times and again. As a result, the complexity of appending N strings each with a limited length, becomes O(N^2) instead of O(N).</p>
-<p>Eliminating such problematic mis-implementations in the code can yield a substantial speed-increase.</p>
+<p>Eliminating such problematic misimplementations in the code can yield a substantial speed-increase.</p>
 <p><a name="Note_about_Order-of-Complexity_Reduction" id="Note_about_Order-of-Complexity_Reduction"></a></p>
 <h3><span class="editsection">[<a href="/w/index.php?title=Optimizing_Code_for_Speed&amp;action=edit&amp;section=15" title="Edit section: Note about Order-of-Complexity Reduction">edit</a>]</span> <span class="mw-headline">Note about Order-of-Complexity Reduction</span></h3>
 <p>It should be noted that some algorithms with a proven lower Big-O notation than equivalent ones, are either too complicated to be effectively implemented or have a huge runtime factor that will make them impractical for most reasonable data-sets, or both. For example, there's an algorithm for finding the Median (= middle element) of an array in linear (O(N)) time, that was discovered in the nineties, but it's very complex and is a very "big" linear time (with a huge factor), that an efficient O(N*Log(N)) sorting would normally be more efficient. That and we are very often interested in the Median for optimizing sorting, and so it would make sense not to use this algorithm in the first place.</p>

File lib/htmls/from-mediawiki/processed/Optimizing_Code_For_Speed-rev1.html

 <p>This document will focus on optimizing code to run faster. However, as you will see later, doing this may involve having to optimize the code in a different aspect. Furthermore, often when programmers are trying to optimize one aspect of a program, they are doing so in order to increase speed.</p>
 
 <h3 id="In_which_programs_is_optimization_required.3F">In which programs is optimization required?</h3>
-<p>There are several type of programs in which optimization is required. One type of them is <a href="http://en.wikipedia.org/wiki/Real-time_computing">real time programs</a>. Despite common mis-conception, these are not necessarily programs that need to be very fast. Instead real time programs are programs that must respond to certain events within a certain time limit that was dedicated to the event. So for example, if the user presses a keyboard key while inside a word processor window, it should display the character relatively promptly. A 5 seconds delay will be unacceptable and as such a word processor is a kind of application that has some real-time constraints.</p>
+<p>There are several type of programs in which optimization is required. One type of them is <a href="http://en.wikipedia.org/wiki/Real-time_computing">real time programs</a>. Despite common misconception, these are not necessarily programs that need to be very fast. Instead real time programs are programs that must respond to certain events within a certain time limit that was dedicated to the event. So for example, if the user presses a keyboard key while inside a word processor window, it should display the character relatively promptly. A 5 seconds delay will be unacceptable and as such a word processor is a kind of application that has some real-time constraints.</p>
 <p>Some parts of real-time systems may need optimization. However, once the time falls below the required delay, no other optimization is necessary. (At least not until testing proves it is again exceeding the limit.)</p>
 <p>Other programs that require optimization are programs that cannot be fast enough. Examples for such programs are Artificial Intelligence programs, games, multimedia programs, virtual machines and interpreters for programming languages, or any type of publicly available library or module whose use "in the wild" may necessitate it to be very fast.</p>
 <p>And naturally another type of programs are programs that are too slow or perceived to be too slow. While programs of some problem domains are very slow due to the complexity of the calculations involved, that is usually not the case, and nothing prevents a program from being fast. Such programs that are considered too slow should be optimized to make them run faster.</p>
 <h2 id="Order_of_Complexity_Optimizations">Order of Complexity Optimizations</h2>
 
 <h3 id="What_is_order_of_complexity.3F">What is order of complexity?</h3>
-<p>Generally, an algorithm has an <a href="http://en.wikipedia.org/wiki/Computational_complexitytheory">asymptotic comptutational complexity</a>. Assuming the input is of size N, we can say that the algorithm will finish at O(N), O(N^2), O(N^3), O(N*log(N)) etc. This means that it is a certain mathematical expression of the size of the input, and the algorithm finishes between two factors of it.</p>
+<p>Generally, an algorithm has an <a href="http://en.wikipedia.org/wiki/Computational_complexitytheory">asymptotic computational complexity</a>. Assuming the input is of size N, we can say that the algorithm will finish at O(N), O(N^2), O(N^3), O(N*log(N)) etc. This means that it is a certain mathematical expression of the size of the input, and the algorithm finishes between two factors of it.</p>
 <p>Generally, the smaller the order of complexity of the program's underlying algorithm, the faster it will run and the better it will scale as the input gets larger. Thus, we should often seek more efficient algorithms in order to reduce the order of complexity.</p>
 
 <h3 id="Some_examples_for_reducing_Order_of_Complexity">Some examples for reducing Order of Complexity</h3>
   .
 </pre>
 <p>And so forth, then the strcat calls will keep starting from the beginning of the string and seek the (increasing) end times and again. As a result, the complexity of appending N strings each with a limited length, becomes O(N^2) instead of O(N).</p>
-<p>Eliminating such problematic mis-implementations in the code can yield a substantial speed-increase.</p>
+<p>Eliminating such problematic misimplementations in the code can yield a substantial speed-increase.</p>
 
 <h3 id="Note_about_Order-of-Complexity_Reduction">Note about Order-of-Complexity Reduction</h3>
 <p>It should be noted that some algorithms with a proven lower Big-O notation than equivalent ones, are either too complicated to be effectively implemented or have a huge runtime factor that will make them impractical for most reasonable data-sets, or both. For example, there's an algorithm for finding the Median (= middle element) of an array in linear (O(N)) time, that was discovered in the nineties, but it's very complex and is a very "big" linear time (with a huge factor), that an efficient O(N*Log(N)) sorting would normally be more efficient. That and we are very often interested in the Median for optimizing sorting, and so it would make sense not to use this algorithm in the first place.</p>

File lib/hunspell/whitelist1.txt

 wikipedia
 Yilmaz
 maneuver
+
+====dest/t2-homepage/philosophy/computers/optimizing-code-for-speed/index.html
+
+286's
+32MB
+64MB
+analyze
+Athlon
+Catalog
+ccna
+Cisco
+C-structs
+Daan
+Dallas1278
+Davara
+Digg
+'Don't
+-ed
+FreeCell
+Gilboa
+GLib
+GLib's
+GMP
+Inline
+inlined
+inlining
+IO
+IPs
+Jguk
+libavl
+libredblack
+Limbic_Region
+LWN
+malloc
+med
+memoization
+Memoization
+memoizing
+Moore's
+OnLAMP
+OSNews
+parallelization
+Parallelization
+parallelized
+parallelizing
+pda_rss's
+PDL
+Pentium's
+perl5's
+PowerBuilder
+Preprocessor's
+qsort's
+Randall
+Reddit
+Refactorings
+Schlemiel
+Schwartzian
+SciPy
+Shrinkwrap
+Spolsky's
+strcat
+strcpy
+structs
+-structs
+Structs
+Tradeoff
+un-inlined
+VB
+whatsup
+wikibooks
+Wikibooks
+XS
+XT's
+icnd
+individually-malloc
+IO-intensive
+misimplementations