WHAT 1.2 Release Notes

WHAT, Wolfberg's Helpful Anagramming Tool, is really a toolbox of integrated powerful tools, with many facilities. From time to time, the program is updated with bug fixes and the support of new features. This page outlines changes made in 2009 through 2011 for WHAT Version 1.2.

Release 90 made 11-Jun-11

(+) should be a new letter and (-) a repeated one. There has been confusion about how these interpreted by the command scanner since a change was made in Apr-06. To find 15-letter words with no repeated letters, use command:
```
  15(+)
```
This is now fixed.
When WHAT and someWHAT are installed, a new icon is now being created for running the program with the Collins lexicons.
The user guide was updated - the section describing the [LEXICONS] section of the .ini file has been augmented to include the optional specification of the lexicon to be used for challenges.

Release 89 made 23-Jan-11

Initializations of random number generators were added, once we learned each program thread has its own seed. With this change, producing random racks using a script will change what racks are produced when WHAT runs multiple times with the same command file.
When doing flashcarding and using commands x, y, z, or d, the comment which WHAT puts out on the next flashcard line is now improved. It had been the case that lowercase letters in the comment had been made green in error. Furthermore, that comment was being reissued on a separate line in error.

Release 88 made 8-Oct-10

Improvements were made in the noting of new settings involved with making new initialization files. The radio buttons in the dialog to create a new initialization file are now better representing the fact that changes were made in values of settings of values which are in the initialization file.

Release 87 made 6-Oct-10

WHAT used to output nothing at all when there was a request to output the slate in the absence of query characters. For example, when you typed the command
```
  foo
```
you were shown an answer of "(nothing)" in red. But then if you issued a command of an apostrophe, which means to show the slate, nothing at all was shown. We do not now think of why this behavior was chosen. With this release, in such a case, you are shown the "(nothing)" message for such a command. If you think of a reason why this change should not have been made, please let us know.
A timing bug was noticed and fixed for a case where this command file was executed:
```
  abc
  #
  def
```
such that WHAT hung after echoing the second line of the file.
There was a problem with minus sign command (just that character on a line), such that this test case produced wrong results: Put the string abc into wordlist 1. Then execute a command file with these two lines:
```
-
/1FC
```
and you saw as output:
```
WHAT?: ABC
WHAT?: ABC

CAB

WHAT?: 
```
where the second query line shows ABC in green. Now that the bug has been fixed, output is:
```
----------------------------------------------------------------------------

WHAT?: ABC

CAB
 
WHAT?: 
```
where the query line shows ABC in green.
The /CW command had been clearing the workspace, but then issuing a prompt on the third line. This has been corrected, so that prompt is made on line 1.
When a command file is used, commands from the file are shown in the workspace. One exception is an /X without error. This makes the workspace nicer to read. The command can be observed in the command history.

Release 86 made 3-Sep-10

The layout of several items in the GUI, especially the Challenge Dialog, were further adjusted to better work on small screens.
When query characters are included on a command line along with an /X command, those characters were being ignored. WHAT is now noting those characters and remembering them, such that if an early line in the command file begins with an exclamation point, it refers to those characters.
A new kind of query was added to WHAT repertoire. WHAT already had a query kind to circulate blanks through a pattern. This included placing a blank before and after the provided string, as well as between each letter/tile of the string. That kind of query is now called "Patterns with Blank Additions". The new kind is called "Patterns with Blank Insertions"; with this query kind, blanks are inserted only between letters/tiles of the provided string. The subcommand to specify Patterns with Blank Insertions is
```
  /.P
```
The existing kind (Patterns with Blank Additions) is specified with
```
  /+P
```
For example:
```
  LEE /.P
```
yields only LEKE, whereas
```
  LEE /+P
```
yields 8 words.

Release 85 made 31-Aug-10

The dialog "Query Filtering Based on what One Blank Matches" was not working when the primary lexicon is Spanish and perhaps even with English lexicons. This has been fixed.
The fonts used for the WHAT GUI were inappropriate for running WHAT on a computer running with large fonts (such as 120 DPI). Nearly everywhere in the WHAT GUI, use of the MS Sans Serif font has been replaced by New Zunica font, which is a better font for scaling with large fonts.
The layout and some of the wording of the Challenge Dialog were further adjusted to better work on small screens and when using large fonts.
There are phrases thoughout WHAT about using CTRL along with C,L,N,R when using a Spanish lexicon, but those phrases used to say "C,N,L,R", which was out of alphabetical order. This has been fixed.
The WHAT Authorization Dialog was tweaked to improve the layout.

Release 84 made 18-Aug-10

The previous release of WHAT fixed many problems with screen layout throughout the program. A few more such problem were then noticed, and this release fixes these. If you are not using a very small screen on a notebook or if you are not using large fonts (such as 120 DPI), then you will likely not notice the problems which this release fixed.

Release 83 made 13-Aug-10

When WHAT was used on a small screen, such as with 800 x 600 pixels, the WHAT window was not being set up correctly. Parts of the WHAT window were off-screen, and it was not possible to make this work adequately. These problems have been fixed mostly. WHAT can be started in a normal or maximized Windows window when the screen size is 800 x 600. There are a couple of problems when using WHAT on such a small screen, and these are that some portion of the windows are off-screen when playing the 5 x 5 Grid Game and the Word-Building Game. Fixing these problems is now considered to be low-priority.
When WHAT was used on a computer where the fonts are not set to normal, which is 96 DPI, the layout of the screen was not maintained. This has been fixed.
Many parts of the GUI were modified such that placements and sizes of dialog windows are a bit changed. This was prompted by doing a full checking for support of the program running on Vista and running with large fonts.
Documentation has been updated to more precisely pin down the suggested screen size for using the program. This is both on the purchase web page and the "WHAT's First" document.
The instructions in the Challenge Dialog were modified slightly. The layout of the Challenge Dialog has been modified, especially when doing tourney adjudications.
The Copyright Notice has been augmented to span years 2005-2010, but it used to indicate only 2005, the original year of the copyright.
If WHAT is running without a definitions file, the definitions window is of little or no use, but it does show. Except, after a challenge dialog is shown, the definitions window had been disappearing. It no longer does.
Let's say you want to see all the 10-letter words which can be made from the top line of a keyboard, such as TYPEWRITER. The WHAT query for this can be
```
  10(QWERTYUIOP)
```
WHAT takes a long time to then find the answer, but it was not issuing any indication that was working. For some long computations, it shows a progress indicator in the status line, but for this kind of query, WHAT was not announcing such progress. This has been fixed.
When using an English lexicon, such as OWL2, the query .. followed by [].= resulted in a message saying what "tiles" are matched by the blank, but this message should mention "letters" instead of "tiles". This has been fixed.
The WHAT initialization file may include a specification of where to create files with challenged words. A user may provide a file prefix, and WHAT suffixes a date specification using 6 digits. If the spec does not include a directory spec (where the spec includes a slash or colon), the file is created in the directory known via environment variables HOMEDRIVE and HOMEPATH. On a Vista system, this usually is directory: C:\Users\<user-name>. On an XP system, this is usually directory: C:\Documents and Settings\<user-name>. This is a change from WHAT's previous behavior, which was to create the file in the same directory as the WHAT executable. This is discouraged on newer versions of Windows.
The import and export dialogs start up with an initial directory for where the files are sought and created. This used to always be the same as the current working directory, but this has been changed to possibly be where the user's own documents are, which is the same directory as mentioned above, based on environmental variables HOMEDRIVE and HOMEPATH.
This topic is subtle, and if you are unable to follow this, just don't worry about it. It probably has never shown up for you, and you are not likely to make queries for which this matters.
When a query produces answers where one of more blanks are matched by letters, WHAT notes which letters were matched. Usually, in such a case, there is one letter matched by a blank, and then the equal sign subcommand indicates the output shown is that set of letters; it is called the blank-matching set. WHAT also makes note when there are two letters in an answer which were matched by blanks. It was recently noticed that there can be queries which can produce some answers using one blank and other answers using two blanks, etc. In these cases, presentations using the blank-matching format (as specified with a colon) were confusing and wrong. This has been repaired by requiring that all answers in a query must have the same number of letters matched by blanks in order to then be used as the basis for presntations based on blanks. An example which demonstrates this is:
```
  .AJ*:
```
The output for this is now an error message indicating the query did not consistently have 1 or 2 blanks matched by letters/tiles. Previously, WHAT tried to output using this format, and it was very confusing and misleading.

Release 82 made 20-Apr-10

The height of the Word-Building Game dialog has been slightly increased so that tiles in the bottom row are no loner chopped off on some screens.
The wording on the Challenge dialog has been altered to be specific about the roles of the challenger and the opponent.
Tilde-N input to the Challenge dialog when doing Spanish challenges has been fixed. Until you get this update, you can use CTRL-N to input a tilde-N.

Release 81 made 11-Mar-10

When executing a /NR command (in a command file of course) which rewinds and gets the next flashcard, there is no longer a problem with the second item in the wordlist being used for flashcarding. Until this was fixed, that item was not being seen as a command.
The commands to yield user-defined sets are supposed to have an optional set number argument, and this was not working as intended. The lack of an argument was being diagnosed. This has been fixed.

Release 80 made 21-Jan-10

The dialog to set up set (B) does not allow zero of any tile; this used to be the case, but it was changed in Release 73, but that change should not have been done.
The outputting of set ($) now includes letters even when they have scores of zero; right now.

Release 79 made 20-Jan-10

Performance of the command to append random racks to a wordlist has been improved. You are now shown a progess indication on the status line, and you may prematurely stop the command using the Esc key. The WHAT User Guide was updated to describe this new behavior.
The dialog to create the above command has been improved such that the number of racks field gets focus and entering numbers in that box is easier.
French tiles are now provided for the Word-Building Game when the primary lexicon is a French one.
The Word-Building Game dialog has been repaired where it had problems during game play, showing strange and wrong results when the player clicked in the grid on its lowest line.
For the Word-Building Game, Help text was updated to include French, and one of the instructions for the game has been fixed, where you had been told you can use a up-arrow to retract a played letter - it should have said a "down-arrow".
The icon installed on the desktop for French use had a wrong "start-in" directory. This has been fixed. But having fixed this, when starting in French, both (B) and ($) sets were not properly initialized, and this has been fixed.
If a user modifies the letters in the bag, this change was not getting reflected everywhere it should, such as when the set (B) is examined. Also the count of the number of letters in that set was not being computed based on the current set. Both of these problems have been fixed.
The WHAT Usert Guide was updated to more completely describe the updating of sets (B) and ($).
The What's Wrong document was updated to represent the current state of the program.
A problem was noticed such that these commands were failing:
```
  />1AAUQ
  /1] [] /A /#1 /QS
```
and this has been fixed.
This document has been added as one of the documents in the WHAT doc directory.

Release 78 made 14-Jan-10

When doing an install, no icon was being installed for French (ODS5) use in the Start->Programs menu, although there is such an icon placed on the desktop. This is now fixed.
An extended FISE lexicon has been added, and it is part of the released WHAT. This has all FISE2009 words plus long Spanish words of length greater than 15. Interestingly, the lexicon with more words is a smaller file, and this has to do how lexicons are encoded to take advantage of common endings of words.
The WHAT executable has internal lexicon numbers dedicated to French and Spanish. One French and two Spanish lexicon numbers have been reserved for the future to make the release of new French and Spanish lexicons not require a new WHAT.exe.
Both Spanish and French lexicons have been given updated short and long names.

Release 77 made 7-Jan-10

Support for French lexicons has been added, and the ODS5 lexicon is now available. The demo form of that lexicon is also available for use with someWHAT. When a French lexicon is selected as the primary lexicon, the tile distribution and tile scores are appropriately updated.
The report to indicate the contents of set ($) has been changed to say there are 26 letters or 28 tiles, rather the total number of all the scores among the tiles of a full bag.
When asking for a highest-scoring playable word in the Word-Building Game, that word is not entered into the current solution automatically, but it is shown at the top of the screen. It is then up to the user to pres the ENTER key to accept that word.
A couple of bugs were fixed relating to the support of up to a limit of 18 lexicons.
It was noticed that someWHAT was incorrectly configured in Release 76, and the problems have been fixed. The wrong lexicons were specified in the desktop icons.

Release 76 made 18-Dec-09

A bug was noticed and fixed involving the filtering by word count and a given member of a wordlist includes a period. This example used to fail:
/>1AZZ. /1[ [] /#1
This query had been finding nothing. It is testing that the one word in wordlist 1 when considered as a pattern yields at least one word. After the bug fix, the correct answer of ZZ. is the result, but the following change also had to be made.
When a word is presented with addiitonal info, such as its score, probability, anagram count, etc., an underscore is now used to separate the various fields of info. Until now, a period was being used for this purpose, but since a period can be part of a presented word when it is in a word list, this was causing confusing output. See the example in the above bug fix.
The installation package employed to do an install of WHAT on a computer has been changed. The previous package was not working on some newer MS Windows operating systems, such as 64-bit Vista and Windows 7.

Release 75 made 14-Dec-09

Solving in the Word-Building Game is now supported. You may request seeing a best-scoring word at any point while playing, or you may ask WHAT to find some very good solutions. You can affect how much looking the program does in finding such solutions. It is unlikely that a highest-scoring solution can be found, but any of the found solutions will be so much better than what a human can find, you may not care about the difference.
A new command has been added which shows all definitions which include a given search string. The command is
/SD<search-string>
where the search string is enclosed within quotation marks. As with the filtering subcommand for definitions including a given string, WHAT virtually appends a space to the end of each definition. WHAT is surrounding your given search string within single spaces. You can inhibit these assumed spaces before or after the string by including a vertical bar there.
A bug in the authorization code was noticed and fixed. This was occasionally causing WHAT to think a given acceptable code was unacceptable. If you are a WHAT user having problems with authorization, Mike will help you work through this.
The /PW command was added in Release 73, but there was a bug when the user provided an optional quoted title; WHAT went into an endless loop. This bug has been fixed.
Some long-term bugs were responsible for some problems when executed command files included lines with a period to indicate a random rack should be generated. Involved with this was a problem in that a line with a comment (starting with double slash) was not being handled correctly. These problems have been fixed.
A bug was noticed and fixed involving the filtering by word count and outputting of canonically-ordered strings. This example used to fail:
/>3Acat // put CAT into wordlist 3 /3[ [] /#=1 /Q;S
This query had been finding nothing. It is testing that the one word in wordlist 3 when considered as a pattern yields one word, and the result is to be output as a canonically-ordered string. After the bug fix, the correct answer of ACT is the result.
WHAT is now set up to support an additional Spanish lexicon should one become available. This is of no interest to users of the program until such an additional lexicon is available.
The Word-Building Game is now providing very good, but not optimal, solving for high-scoring solutions and for the highest-scoring individual words which are playable.

Release 74 made 12-Oct-09

Some refinements were made for the Word-Building Game. With this release, the program is not yet solving games, but it is expected the next release will support solving to the extent a very good, but not necessarily optimal, solution can be computed.

Release 73 made 20-Sep-09

A major new feature is the support for a Word-Building Game which is based on a game found on old TIVO devices. It is called Wordsmith there, and this is a game in which you choose among letters at the top of each of 12 columns to build up words of length 3 through 12 tiles. You try to get the highest score for all your built words, and words are scored by multiplying the length times the total of the individual scores of the tiles in the word.

You will usually ask WHAT to make a random grid of candidate tiles, but you may provide your own, similar to the way BOGGLE works in WHAT. Although WHAT can solve a BOGGLE grid completely, it is not yet equipped to solve the Word-Building Game, but this will be provided in a future release.

There is support for remembering games you want to remember in a history.

This game is supported for both English and Spanish. BOGGLE is supported only for English at this time.
A new scoring option was added for scoring words as they are scored in the Word-Building Game; this is the sum of the tile scores times the word length. The subcommand to indicate this is:
/@W
A major new feature has been added which is usable only for English, since it is based on the existence of definitions, and there are no definitions yet supported for Spanish. You can now have a filter for a query which constrains words to have a given string found (or not found) in its definition. For example, /"dog" will require that a word have the 5 characters " dog " in its definition. When more than one such subcommand is given only the final one in a query pertains. So if you want to find queries which contain both " dog " and " v ", which indicates the word is a verb, you have a make a second query using the results of the first query as the basis of the words. For example:
```
   * /"dog" \
```
[] /"v" "
The final quote on the above line indicates WHAT should present definitions.

To help in searching for individual words, WHAT virtually appends a space to the end of each definition.

WHAT is surrounding your given string within single spaces. You can inhibit these assumed spaces before or after the string by including a vertical bar there.

To filter for words which do not contain a given string in their definition, start your string (after the opening quote) with an exclamation point. At least for now, the definitions file includes no exclamation points.

As with other filtering commands:
```
   /"-
```
turns off definition filtering.

Filtering based on definitions is optimized for queries which are only an asterisk, either an anagramming or pattern match query. It is much quicker to do:
```
   * /"dog" /|=7
```
than to run a pattern match query
7. /"dog"
This matters when there are a lot of words to be considered, such as with this example.

Section 13.7.5 has been added to the What User Guide to describe this feature.
A bug was found and fixed which affected presented output after a user interrupts a query by pressing ESC. Two problems were fixed: partial output was not always shown, and words shown were not being marked correctly as to whether they were in the primary vs. secondary lexicons. Words appeared to all be new.
The command to print the workspace has been changed. It used to be:
/""
but it is now:
/PW
When commands are placed into the workspace by WHAT, they are now generally followed by a space, which makes command more readable and less susceptible for unintended meaning. For example, /PW is now a command and so it is important that a space follow the /P command to indicate pattern matching, since it can be then followed by a W as a query character (using English lexicons).
Two documents have been updated to include the descriptions of new and changed commands. You can see these on the WHAT website and/or you can download the updated files via the facility to update WHAT files:
- WHAT User Guide
- WHAT Command Language
If you make this query when using a Spanish lexicon:
```
   LILIIII /QS
```
WHAT outputs
```
   IIIIILL
```
and when that is used futher it appears to have the LL character instead of two Ls.

This is a bug which is fixed. WHAT will alternate the case of successive characters to avoid ambiguity. This applies also to RR and CH.
The dialogs to set up sets ($) and (B) were not allowing the lower choices to be zero, but this has been fixed.
WHAT had been ignoring filtering requirements when the output is strings. This has been fixed. The example which demonstrates this is:
/($)=(AEIOU) CASA /$=3 /QS
WHAT had been ignoring the /Z zero-score for blanks option when a word is being scored with a starting location. For example, this query was producing wrong results:
.u,? /<$ $ /Z /@5B.

Release 72 made 28-Aug-09

The Spanish lexicon is now labelled with:
FISE2009 Int'l. Spanish = Lexicón Oficial de la FISE de 2009

The previous description did not have the equal sign, and it was too long.
Two documents have been updated to include the descriptions of the new commands which append to wordlists:
- WHAT User Guide
- WHAT Command Language
A new command has been added which causes WHAT to output a given number of random racks to a specified wordlist. It appends the racks, allowing for duplicates in the output. As with creating random racks in the workspace, when the lexicon is a Spanish one, spaces are used to separate the tiles. This is the form of the command:
```
   /. <#-racks> >  A
```
The extra spaces are optional.

There is GUI access to this command both on the Random Racks tab at the upper right and on the Command menu.
Another new command has been added which allows you to append an arbitrary line to a wordlist. This can be useful in making flashcards. The form of this command is:
```
   /> <wordlist-#> A<arbirary-text>
```
There is no GUI access to creating this command.
Having added the feature to produce random racks into a wordlist, you can now run a sequence of commands and see the percentage of racks which produce bingos:
```
   /.10000>1A      // append 10,000 random racks to wordlist 1
   /1[ [] /A /#1 # // using wordlist 1, count the number of racks which produce bingos
   /1D             // delete wordlist 1
```
Here are the results of 6 runs when using the Spanish lexicon: 2192, 2143, 2114, 2203, 2233, 2192.
Command scanning has been modified to allow for spaces among the arguments of the yield command (/Y...).

Spaces are also now optional after /< and /> as the start of commands.
The /US command to raise the case of letters on the slate had been missing raising the case of tilde-N. Similarly, the /LS command to lower the case of letters on the slate had been missing lowering the case of tilde-N. Both problems have been fixed.
WHAT was not diagnosing the inputting of tilde-N when dealing with a primary lexicon which is for English (i.e., not Spanish). This problem has been fixed.
It has been observed that when WHAT outputs a lot of lines into the workspace, the ability to type in commands in the workspace may be disabled. This bug has not been purused yet. If this happens, you can resume typing in the workspace only after you clear the workspace, which can be done via the GUI on the WHAT tab at the upper right.
WHAT had problems highlighting the correct characters in green when outputting long lines when using a Spanish lexicon. Here is an example demonstrating the bug:
```
WHAT?: emborracha

EMBORRACHA
 
WHAT?: *[]*/|=15 3'
       (first 3 items only)
DESEMBORRACHABAIS DESEMBORRACHARAIS DESEMBORRACHAREIS
```
```
On the above line the 1st word has green DES and BAIS;
                      2nd word has green DE  and ARAIS;
                      3rd word has green D   and HARE.
You can see by looking at the slate that des is lowercase,
the next 8 tiles are uppercase and the final 4 are lowercase,
so the bug is in how WHAT decides which letters to change to green.
```
The bug turned out to be based on presenting a word length of greater than 15, which happens when a 15-tile word has any digram tiles. The longest word length for presentation is 18 and not 15. The FISE lexicon is therefore being updated (since the lexicon file includes a field which indicates the longest word), but meanwhile there is a code change in WHAT such that even with the old (current) FISE lexicon, the longest word length is being repaired. At least this word has 3 digrams: ACHICHARRONARIAMOS
When filtering by the number of words, WHAT was ignoring the setting to augment the slate; instead it was replacing the slate. Filtering by score was not doing this. Here is an example:
```
ARC /1W
CAB
/1[! /+S!
[1-2] /#=1
```
The result does not include CAB - it's just ARC.

This bug was specific to when a wordlist other than the slate is being used as the basis of word references (as specificed above by /1[). This bug was fixed.

With this bug fixed, the faster method of finding 15s with imbedded 8s can be done in fewer steps:
```
15. # 
/15W    // save all the 15-letter words in wordlist 15
/15[!   // use wordlist 15 as the basis of word references
/CS     // clears the slate
/+S!    // augment the slate with query results long-term
[2-9]  /#=1 #  // note those 15s whose 2nd-9th letters are words  
[3-10] /#=1 #  // continue for other subwords
[4-11] /#=1 #
[5-12] /#=1 #
[6-13] /#=1 #
[7-14] /#=1 #
```
The resulting 4581 words are on the slate.
If a wordlist has letters/tiles with single-spaced spacing between those letters, as is the case for random racks produced for Spanish, then when that wordlist is used as the basis for word references, the first space in that wordlist word was stopping the scan. WHAT has been changed such that two sequential spaces or slashes stops the scan (and nothing else). Here is an example which now works, but it had been failing:
/>5AM A L C H I N E /5[ [] /A or /5[ [] /A /#1
If a wordlist has a line which includes a slash, such as
```
xyz/s
```
and there are lowercase letters, when the line is presented in the workspace, what is shown in green was wrong. In this case three characters in green started at the Z and not at the X. This has been fixed. This does show that flashcards are better prepared with uppercase letters to avoid having green letters.

Along with this fixed bug is a related one in that if a flashcard in Spanish has a lowercase tilde-N, it was not being handled correctly.

Both of these bugs are fixed.
If a wordlist, such as wordlist 5 had these two lines:
```
C O O E E T ?
L D R S A C E
```
When you ran the command:
/5[ [] /A
the answer had been 20 words which answer LDRSACE?, but there was no blank on the second line, and any results of the first word in the wordlist was missing - it should have been 8 other words.

If only the first word is in the wordlist, nothing is found, as if the question mark became part of the next line.

This bug (or group of bugs) was fixed. It is a bit strange to have question marks in a wordlist, and as such, this was not supported until now. It is still not fully supported (for all kinds of queries), but it can at least be used for an anagramming query to see what words of a wordlist lead to any results.
If a wordlist, such as 13 has these 2 "words":
E A D Ñ A T S E A D S S S U
and we run
/13[ [] /A /#1
only the first "word" is in the result:
E.A.D.Ñ.A.T.S
But the second one should also be there.

This bug was fixed by fixing the my_stricmp function in the code, so that it can compare strings which include spaces.

Release 71 made 18-Aug-09

The production of random racks other than by using the period and R commands had been done wrong. This is fixed.
When clearing everyting via the WHAT tab in the upper right, the (B) set was not set correctly for Spanish. This has been fixed.
Word "probabilities" were not being computed correctly when using a filtering by probability. This command had been producing incorrect results for Spanish:
7. />% /%>0 % 25'
There had been words shown with probability of 0, but the quesy is seeking words with a probability greater than 0. This is fixed. Also, you can now see there are 592 7-letter words in the lexicon with a "probability" of 0.
There was a bug such that ZURUPETO/&1 was not being output when it should be. The idea was to find 8-letter words with one anagram which do not include any 7. The command which was tried to get the 8's was the command:
8./&1\
but /&1 means the word has one or more anagrams; it means the same as /&>=1

So if you are seeking 8's with one anagram, there are 2 "anagrams" in the rack, and so the query should have included /&=2 instead. The query as written would find all 8's and the /&1 would have no effect. Let's say that was what was intended afterall. The next command mentioned in the bug report
[]/a/|=7/#=0#
was then finding which of those 8's contained no 7's. WHAT had incorrectly said there were only 5 and it was missing ZURUPETO among many others. With the bug fixes, WHAT says there are 2663 such 8's, ZURUPETO among them.
WHAT has been having problems with scoring Spanish words, especially when filtering is done based on scoring. Several problems in this area were fixed. You can now ask WHAT for the highest-scoring triple-triples starting at A1 and the highest opening plays which include the star.
Another small bug was fixed which was involved with what letters are shown as progress indicators on the lower status line when a command takes a long time to execute. It had been the case that when letters A through Z had been shown, the indicator continued to start over with A, but the line was extended. With this fixed, the line starts over showing just the A, so you can see each step of progress.

Release 70 made 8-Aug-09

A new command now exists which allows you to ask if a string is a word in a given lexicon. For example, if you are working with FISE 2009 as your lexicon, you can ask if a string is in OWL2 with the following command:
JUDY/-"OWL2"?
You can then see if it is in CSW (Collins for British play):
JUDY/-"CSW"?
There are several fixes for reported bugs in the Spanish support:
- probabilities are now computed correctly
- scores of words are now computed correctly
- finding imbedded words in a given string using /I is working

Release 69 made 2-May-09

Releases 69-65 are for WHAT Version 1.2, which is where support for Spanish began. A few Spanish users were helpful in making early use of the new support, and they helped uncover several problems which were then fixed. There are no details available for exactly what was being done in each of these early releases to support Spanish. Here are the various release dates:

Release 68 made 22-Apr-09
Release 67 made 16-Apr-09
Release 66 made 14-Apr-09
Release 65 made 12-Apr-09