Commits

Shlomi Fish committed 4f6e7af

Finished the spell-checking. Yay!

  • Participants
  • Parent commits 68e062a

Comments (0)

Files changed (14)

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#\A\Qdest/t2-homepage/recommendations/index.html\E#' |
     grep -vP 'dest/t2-homepage/philosophy/obj-oss/objectivism-and-open-source/' |
     grep -vP 'philosophy/foss-other-beasts/revision-2/' |
     grep -vP 'guide2ee/undergrad' |
                 {
                     text => "Political Essays",
                     url => "philosophy/politics/",
-                    title => "Essays about Politics and" .
+                    title => "Essays about Politics and " .
                         "Philosophical Politics",
                     expand => { re => "^philosophy/politics/", },
                 },

lib/docbook/4/xml/rindolf-spec.xml

     </para>
 
     <para>
-        Rindolf maintains backwards-compatiblity because Perl 5 is good
+        Rindolf maintains backwards-compatibility because Perl 5 is good
         enough as a basis for a language. More importantly, it is a language
         that is in wide use today, and people depend on.
     </para>
         Functional Programming, Exceptions, text-processing, garbage collection,
         nested data structures, arbitrarily-sized data, etc. I'm not saying
         it's a perfect language, but inventing something entirely different,
-        just to solve its defincies is sure to make many users (if not most)
+        just to solve its deficiencies is sure to make many users (if not most)
         unhappy.
     </para>
     <para>
     </para>
     <para>
         Rindolf will still essentially be Perl 5-like with a Perl 5 feel
-        and behaviour. Moreoever, C++ has proved of some use to many projects,
+        and behaviour. Moreover, C++ has proved of some use to many projects,
         and is still commonly used. As much as there is a hype about Java and
         .NET, they are not compatible with ANSI C, and so aren't actually
         a replacement for C++.
         it is a good thing, but also to try not to lose ground. Many times
         two competitors each gain new users. Many times users are gained by
         one on the expense of the other. At the moment, Perl faces competition
-        from Python, Ruby, Tcl, O'Caml and some other minor players. Our most
+        from Python, Ruby, Tcl, OCaml and some other minor players. Our most
         serious competitor is Python.
     </para>
     <para>
         supposed advantages of its language, how maintainable the code can
         become, and how everyone is capable of understanding it. While Python
         has many features Perl does not yet have, it also does not have many
-        others (here documents, labeled loops with breaking and continuing, a
+        others (here documents, labelled loops with breaking and continuing, a
         continue block, the use strict pragma and so forth). It also overloads
         every operator to many things: + can be used for both adding numbers,
         concatenating strings and concatenating arrays, three uses that are
         afterwards become familiar with other languages that are of lesser
         significance to the world). I would recommend someone to start with
         Perl instead, but this is a difference of opinions between me and
-        Raymond, which is not productive to delve on. (he took the time to
-        write the HOWTO and so he gets to endorse his paritcular favourite)
+        Raymond, which is not productive to delve on. (He took the time to
+        write the HOWTO and so he gets to endorse his own favourite)
     </para>
     <para>
         My point in making Rindolf is to make sure it has most of the important
         The Perl niche is high-level languages
         optimized for writing a lot of code quickly, commonly referred to as
         "scripting languages". These are the languages that most people like
-        for their day to day hacking, that can be used as subtitute for shell
+        for their day to day hacking, that can be used as substitute for shell
         scripts (like I did when I first worked as a web-technician on UNIX),
         and can be used for GUI programming, numerical programming (with some
         extensions), simple games, text processing (naturally), web scripting,
 </screen>
         </para>
         <para>
-            This should make it more convenient that specificying
+            This should make it more convenient that specifying
             <literal>package Hello;</literal> and
             <literal>package Hello::Good;</literal> and so forth.
         </para>
         </para>
         <para>
             This filesystem will have support for most basic facilities (File
-            I/O, sockets, pipes, ioctl's and fcntl's, asyncrounous I/O, etc)
+            I/O, sockets, pipes, ioctl's and fcntl's, asynchronous I/O, etc)
             and should be flexible enough. Typeglobs will use it, as will all
-            other modules (directly or indiretly) and it will behave in a
+            other modules (directly or indirectly) and it will behave in a
             completely Perl 5-ish manner.
         </para>
     </section>
         </para>
         <para>
             The new statement <literal>line_pt_return</literal> will always be
-            non-proper tail recursive. A pragrma
+            non-proper tail recursive. A pragma
             <literal>use Recursion</literal> will exist that will enable to
             decide how a plain <literal>pt_return</literal> will behave, and
             should be very flexible in doing that.
 
 # Define a pattern for (x,y)
 my $pt_pattern = "\s*\(\s*(\d+)\s*,\s*(\d+)\s*\)\s*";
-# Define a patern for an array of points [pt1,pt2,pt3,pt4]
+# Define a pattern for an array of points [pt1,pt2,pt3,pt4]
 my $array_pattern = "\[(?:${pt_pattern}\s*,)*${pt_pattern}\]";
 # Define a pattern for an array of arrays of points arr1,arr2,arr3
 my $whole_pattern = "(?:${array_pattern}\s*,)*${array_pattern}"

lib/hunspell/whitelist1.txt

 begets
 misperceptions
 devaluating
+compatiblity
 
 ====dest/t2-homepage/index.html,dest/t2-homepage/old-news.html
 
 non-MSIE
 Non-SQL
 NTs
-O'Caml
+OCaml
 Oggs
 OpenACS
 Perl's
 Pseudocode
 SY0-201
 Tetris
+
+====dest/t2-homepage/rindolf/index.html,dest/t2-homepage/rindolf/rindolf-spec/index.html,dest/t2-homepage/rwlock/index.html,dest/t2-homepage/rwlock/linux-kernel/index.html,dest/t2-homepage/shlomif.il.eu.org-questions.html,dest/t2-homepage/site-map/index.html,dest/t2-homepage/toggle.html,dest/t2-homepage/wonderous.html,dest/t2-homepage/work/academic/Thermo/Material-Summary/index.html,dest/t2-homepage/work/hire-me/hebrew.html,dest/t2-homepage/work/hire-me/index.html,dest/t2-homepage/work/index.html,dest/t2-homepage/work/private-lessons/index.html,dest/t2-homepage/work/private-lessons/tutor-ad.html,dest/t2-homepage/wysiwyt.html
+
+_
+0s
+0's
+11's
+1D
+1w-1w
+21h
+2w-2w
+3k
+5-ish
+ac
+ad-hoc
+aFile_
+another_func
+Arafaat
+ARGV
+Arielle
+arr1
+arr2
+arr3
+array_pattern
+awk
+BillScript
+CE
+class1
+class2
+codebases
+'counter
+CR-LF
+det
+DLL
+DNS
+Eitan
+eu
+Evan
+EXE
+extern
+fcntl
+fcntl's
+FileHandle
+filehandles
+filenames
+filesystem
+FP
+gcd
+Gtk
+IE4
+incorrections
+int
+ioctl's
+IPWUG
+_is_
+ISA
+KRNL32
+lex
+line_pt_return
+linux-2
+LOCs
+lowercase
+matrixes
+Matrixes
+Movies
+msg
+Muli
+myclass
+myclass-
+MyClass
+my_func
+'name
+namespace
+Namespace
+namespaces
+new-fangled
+NT's
+object_class
+object_class-
+O's
+perl5
+Perl5-ing
+PerlDL
+perl's
+Perl's
+Phil
+pl
+POSIX
+pragma
+'pt
+pt1
+pt2
+pt3
+pt4
+pt_pattern
+pt_pt_return
+pt_return
+QBASIC
+Refactoring
+Refa’el
+RefHash
+Regex
+Rindolf-specific
+RR
+-'s
+scriptability
+set_default
+SICP
+Smalltalk
+Solaris
+Sp
+SPEC
+sticked
+StrictHash
+sys-admins
+t2
+Tcl
+technion
+Tel-Aviv
+test_flock
+testking
+Thermo
+Todo
+TogSqrs
+toolbars
+typeglobs
+Typeglobs
+typeref
+uppercase
+usr
+val
+whole_pattern
+Win95
+xor
+XORed
+yacc
+Yassir
+ZThreads
+ל-WWW
+OCaml

lib/pages/t2/hire-me.wml

 
 <p>
 I am well-aware of web standards compliance, many browser compatiblity
-issues, accessibility, usability, and other imporant factors in designing
+issues, accessibility, usability, and other important factors in designing
 a site. I may require the assistance of professional CSS or graphics
 designers. (Unless you do not require the page to be very visually
 appealing.)
 <a href="http://subversion.tigris.org/">Subversion</a>, HTML or C programming. I have
 already given many presentations as part of the meetings of
 computer-related clubs or as part of conferences in Israel. At present, I am not a very
-good presentor, but I’m trying to improve and I found some useful resources
+good presenter, but I’m trying to improve and I found some useful resources
 for giving effective presentations.
 </p>
 

lib/presentations/qp/web-publishing-with-LAMP/Contents.pm

                                     'url' => "ruby.html",
                                 },
                                 {
-                                    'title' => "O'Caml",
+                                    'title' => "OCaml",
                                     'url' => "ocaml.html",
                                 },
                                 {

lib/presentations/qp/web-publishing-with-LAMP/src/intro/P.html.wml

 Pike.
 </li>
 <li>
-<a href="http://www.ocaml.org/">O'Caml</a>.
+<a href="http://www.ocaml.org/">OCaml</a>.
 </li>
 <li>
 Java Server Pages.

lib/presentations/qp/web-publishing-with-LAMP/src/server-technologies/sss-overview/other/ocaml.html.wml

 
 <points>
 <li>
-<a href="http://www.ocaml.org/">O'Caml</a> is a strongly-typed, object-oriented
+<a href="http://www.ocaml.org/">OCaml</a> is a strongly-typed, object-oriented
 , functional language.
 </li>
 <li>

t2/lecture/Freecell-Solver/Summary-deprecated.txt

 ** Two tests are special: moving a freecell or stack card to the foundations.
     Moving a card to the founds where both of the founds of the other colour
     are higher than its card number plus 2. In that case if the child-state is
-    not solveable neither is the original state.
+    not solvable neither is the original state.
 
 ** Note that the entire checking and adding code for new states was
 implemented inside the tests code. (not in a separate function).
 
 ** Out of which, some were terminated in the middle.
 
-** Some boards were reported by the program as unsolveable. (as I discovered
-later, they were all solveable).
+** Some boards were reported by the program as unsolvable. (as I discovered
+later, they were all solvable).
 
 ** I placed Freecell Solver version 0.2 on a web-site, and posted an
 announcement for it on Freshmeat.
     3. sfs_check_state_begin
     4. sfs_check_state_end
 
-    All the tests excepts the two NSFOS (not solveable for original state)
+    All the tests excepts the two NSFOS (not solvable for original state)
     used sfs_check_state_begin and sfs_check_state_end.
 
     The two NSFOS states used just sfs_check_state_init and

t2/lecture/Freecell-Solver/Summary.txt

     I later improved some of these moves and added an extra one.
 
     Due to their multi-moves heuristic nature, it is possible that some boards
-    are solveable, yet cannot be solved by FCS.
+    are solvable, yet cannot be solved by FCS.
 
 * Once the program finds a solution it outputs the intermediate boards to
     the screen.

t2/rwlock/index.html.wml

 Many RWLock implementations arbitrate the various readers and writers in a
 manner that may cause starvation of either readers or writers. For instance,
 a readers/writers lock that prefers readers may cause a writer to starve
-(i.e: wait for a very long time or indefinetly) if there are two and more
+(i.e: wait for a very long time or indefinitely) if there are two and more
 competing readers.
 </p>
 
 A First-Come First-Served (FCFS) RWLock solves this problem by making sure
 that the pending threads are served at the same order as the time of their
 arrival. Thus, starvation is eliminated assuming that a thread does not
-obtain the lock indefinetly (which in any case should not happen in a
+obtain the lock indefinitely (which in any case should not happen in a
 well-designed system).
 </p>
 

t2/toggle.html.wml

 <a href="#One_Dimensional_Board">Analysis of a 1-D Toggle-board</a><br />
 <ul>
 <li>
-<a href="#lemma1">Lemma 1: 1D is always solveable if vector 100..00 can be
+<a href="#lemma1">Lemma 1: 1D is always solvable if vector 100..00 can be
 formed.</a>
 </li>
 <li>
-<a href="#lemma2">Lemma 2: 1D is always solveable only for N=3k and
+<a href="#lemma2">Lemma 2: 1D is always solvable only for N=3k and
 3k+1</a>
 </li>
 </ul>
 <a href="#Two-Dimensional-Board">Main (2-D) Theorems</a><br />
 <ul>
 <li><a href="#theorem1">Theorem 1:
-(3k+2)^2 boards are not solveable for every state.</a>
+(3k+2)^2 boards are not solvable for every state.</a>
 </li>
 <li>
-<a href="#theorem2">Theorem 2: 3k and 3k+1 2-D boards are solveable
+<a href="#theorem2">Theorem 2: 3k and 3k+1 2-D boards are solvable
 for every state.</a>
 </li>
 <li>
-<a href="#theorem3">Theorem 3: Solveable 3k+2 boards can be solved
+<a href="#theorem3">Theorem 3: Solvable 3k+2 boards can be solved
 by the one way algorithm.</a>
 </li>
 <li>
 <h3 id="lemma1">Lemma 1</h3>
 
 <p>
-A 1-D toggle field is solveable for every state if (and only if)
+A 1-D toggle field is solvable for every state if (and only if)
 the vector 100...000 can be formed as combination of the
 presses.
 </p>
 -------------
 001000...00
 and from here it can be proved inductively that the vectors with all 0s
-and one 1, are solveable. Since this is a basis of {1,0}^N then every state
-is solveable. (i.e contained in Sp{Presses} )
+and one 1, are solvable. Since this is a basis of {1,0}^N then every state
+is solvable. (i.e contained in Sp{Presses} )
 
 </pre>
 
 <h3 id="lemma2">Lemma 2</h3>
 
 <p>
-A 1-D toggle field of size N is solveable for every state if N = 3k
+A 1-D toggle field of size N is solvable for every state if N = 3k
 or N = 3k+1 and isn’t if N = 3k+2 for some non-negative integer
 k.
 </p>
 contains 1 at the top-left cell and below a Presses Matrix of size N-2) =
 det (PM(N-1)) XOR det(1 * PM(N-2)) = det(PM(N-1)) XOR det(PM(N-2)).
 
-Hence, it’s a XOR of the detereminants of the two previous matrixes. (A
+Hence, it’s a XOR of the determinants of the two previous matrixes. (A
 boolean Fibonacci series :-) )
 
 Recursively, we get a repeating sequence of
 
 Matrixes with a zero determinant cannot form every vector, and vice versa.
 
-It can also be proved (at least for the solveable cases) using Lemma 1.
+It can also be proved (at least for the solvable cases) using Lemma 1.
 For N=3k 1000....000 can be formed by:
 1110000...0000         XOR
 0001110...0000         XOR
 11111111111111111
 
 and thus the dimension of the span is less than n, and so not every state is
-included in it, and is solveable.
+included in it, and is solvable.
 
 
 
 
 <h3 id="theorem1">Theorem 1</h3>
 <p>
-2-D (3k+2) * (3k+2) boards are not solveable for every state.
+2-D (3k+2) * (3k+2) boards are not solvable for every state.
 </p>
 
 <pre>
 00000.111
 00000.011
 
-and Lemma 2 proved that for N=3k+2 it has unsolveable states. If some
+and Lemma 2 proved that for N=3k+2 it has unsolvable states. If some
 formations of the first row cannot be solved by any combination of the
 presses on the block, much less the entire board can be solved for every
 state.
 <h3 id="theorem2">Theorem 2</h3>
 
 <p>
-2-D boards of size 3k * 3k or (3k+1) * (3k+1) are solveable for
+2-D boards of size 3k * 3k or (3k+1) * (3k+1) are solvable for
 every state.
 </p>
 
 <pre>
 Proof:
 If we restrict ourselves to the presses on cells of one column, then we get
-an array of rectangular vectors with a fixed horizontal postion and width
-and a y-dimensions that resemble the 1-D toggle-squares vector set. e.g:
+an array of rectangular vectors with a fixed horizontal position and width
+and some y-dimensions that resemble the 1-D toggle-squares vector set. e.g:
 110000
 110000
 000000
 and the same for every other column. Now, if we look on any row of cells,
 we will see that the “sticks” that were generated from the various columns
 in that row are also the 1-D TogSqrs sequence. Because N=3k,3k+1 again,
-every row is solveable for all states, and therefore, the entire board is
-solveable for all states.
+every row is solvable for all states, and therefore, the entire board is
+solvable for all states.
 
 Diagram:
 110000 , 111000 , 011100 , 001110 , 000111 , 000011
 
 <h3 id="theorem3">Theorem 3</h3>
 <p>
-Solveable states of 3k+2 boards can be solved by the one-way
+Solvable states of 3k+2 boards can be solved by the one-way
 algorithm.
 </p>
 
 In a 1-D board where N=3k+1 the two-way method as is, will ping the
 possible remaining 1 back and forth between the two edges. Therefore if
 there is a state of 1000...0 than one should use the leftmost press to
-change it into 0100...000. Then, by repeatetive pressing to the right
+change it into 0100...000. Then, by repetitive pressing to the right
 of the leftmost filled square, one gets to the 0...11 state, which is
 afterwards cleared.
 
 1. In N=3k+1 the two-way method as is, will ping the possible remaining
 1 back and forth between the two edges. Therefore if there is a state
 of 1000...0 than one should use the leftmost press to change it into
-0100...000. Then, by repeatetive pressing to the right of the leftmost
+0100...000. Then, by repetitive pressing to the right of the leftmost
 filled square, one gets to the 0...11 state, which is afterwards
 cleared.
 
 <h2 id="dim_press_span">The Dimension of the Presses Span in 3k+2 boards</h2>
 
 <pre>
-(3k+2)*(3k+2) boards are not solveable for every state. The solveable
+(3k+2)*(3k+2) boards are not solvable for every state. The solvable
 states form a vector field which is formed by the spanning all the
 presses. Since, in this case it does not include all the states, I
 wondered if we can calculate its dimension or characterize it somehow.
 every possible state (Lemma 1).
 
 Since the 1-D clearing mechanism for 3k+2 uses only the leftmost 3k+1
-cells to clear every solveable state (part of Theorem 3), then
+cells to clear every solvable state (part of Theorem 3), then
 their presses are a valid basis for this linear space.
 
 The one-way - one-way clearing algorithm which was proved in Theorem 3,
 uses only a (3k+1)*(3k+1) square of presses to solve the entire board.
 Ergo, the dimension is (3k+1)^2 or less. I believe it _is_ (3k+1)^2 and
 I think I can prove it by showing that the presses of a corner
-(3k+1)*(3k+1) are linearly independant. In the boolean field the
+(3k+1)*(3k+1) are linearly independent. In the boolean field the
 meaning is that any number of them other than zero XORed together will
 not generate the clear state.
 
 certain number of presses in the square can form the clear state. If
 so, then Pr(4,4) cannot be one of them because it is the only press
 that can affect square (5,5). Moreover, Pr(3,4) and Pr(4,3) cannot be
-included either, becuase, once Pr(4,4) is eliminated they are the only
+included either, because, once Pr(4,4) is eliminated they are the only
 ones that can affect (4,5) and (5,4) respectively. And so forth,
 proving that that all the presses of cells (1,4)-(4,4) and (4,1)-(4,4)
 cannot be part of the zero sum.
 
 The same can be deduced for the next layer starting from Pr(3,3), which
 is the only vector left that can affect square (4,4). And so-on for the
-other layers, proving that they are a linearly independant set of
+other layers, proving that they are a linearly independent set of
 vectors. In conclusion, there cannot be less than (3k+1)^2 vectors that
-span the space of the solveable states of (3k+2) boards.
+span the space of the solvable states of (3k+2) boards.
 
 </pre>
 

t2/wonderous.html.wml

 
 <li>
 Windows 95 supply DOS programs with int 21h functions for long
-file names. Thus, DJGPP ports of UNIX utilites can work in style.
+file names. Thus, DJGPP ports of UNIX utilities can work in style.
 Windows NT, on the other hand, does not. Thus, DJGPP programs cannot
 work in style.
 </li>

t2/wysiwyt.html.wml

 dirty and broken as time goes by.</p>
 </li>
 
-<li><p><b>Improvement to Windows fonts</b> - a new font labeled <i>Times and again Roman</i>
+<li><p><b>Improvement to Windows fonts</b> - a new font labelled <i>Times and again Roman</i>
 is now available for installation. This font looks much like <i>Times New
 Roman</i> except for some important alterations. Among other adjustments, the
 lowercase and capital ‘O’s were added a small beard and a hat, the lowercase