WHAT User Guide (14-Aug-16)

This is a user guide for the powerful second-generation anagramming program named WHAT, for Wolfberg's Helpful Anagramming Tool. WHAT is really a toolbox of powerful tools, with many facilities. You can make effective use of WHAT right away by using just a few of its key features, and you can learn what these are in an introductory document entitled "WHAT's First".

Contents

  1. History
    1. Mike's Credentials
  2. WHAT Documentation
  3. Electronic Word Aid Features
  4. Examples and Applicability
  5. Command Language Orientation
  6. The GUI
    1. Workspace Size and Line Wrapping
    2. Menus
    3. Accelerator Keys
    4. The Tab Controls
    5. Fly-By Hints
  7. Reading this Document
  8. Style of WHAT Use
  9. Command Type-in
    1. Comment Commands
    2. Command History
  10. Short-term and Long-term States
  11. Canonical Ordering
  12. The Slate
    1. Categories of Slate Contents
  13. Commands and Queries
    1. Errors and Warnings
    2. Letter Mapping
    3. One-Letter Commands
    4. Query Constituents
      1. Query Character Specifications
      2. Subtracting Query Letters
      3. Circulating the Blank
      4. Steals
      5. Two-Word Anagramming
      6. Character Conventions
    5. Letter Sets
      1. Built-in Sets
      2. Word-based Sets
      3. Specified Sets
      4. User-Defined Sets
      5. Query-based Sets
      6. Set Contents
      7. Examining Sets
      8. Redefining Set (B)
      9. Redefining Set (P)
      10. Redefining Set ($)
    6. Wordlists
      1. Moving Items among Wordlists
    7. Labels
    8. Source of Input for Queries
    9. Source of Words for Word References
    10. Scoring of Words
    11. Word Lengths
    12. Word Probabilities and Playability
    13. Number of Words
    14. Number of Anagrams
    15. Anagrams
    16. Hooks
    17. Query Filtering
      1. Filtering for Word Length
      2. Filtering for Word Count
      3. Filtering for the Blank
      4. Filtering for Hooks
      5. Filtering for Definition Contents
    18. WHAT Command Repertoire
  14. Slate Presentation
    1. Outputting Strings
    2. Characters Matched by a Blank
    3. Definitions
    4. Presentation Format
    5. Presentation Details
    6. Sorting Orders
    7. Case of Letters in Query Output
    8. Probing the Slate and Other Wordlists
    9. Selecting Lexicons
  15. Multiple Commands on One Line
  16. A Review of Query Processing
  17. A Review of Slate Presentation
  18. File Reading and Writing
  19. Command Files
  20. Printing
  21. Generating Random Racks
  22. Challenges
    1. Automatic Reversion to the Challenge Dialog
    2. Lexicon Transition Challenges
  23. Probe Answer Window
  24. Flashcarding
    1. Flashcard Preparation
  25. Playing the 15 x 15 or 21 x 21 Grid Game
  26. Playing the 5 x 5 Grid Game
  27. Playing the Word-Building Game
  28. Starting WHAT
    1. Initialization File
      1. [LEXICONS] Section
      2. [DEFINITIONS] Section
      3. [PLAYABILITY] Section
      4. [WORKSPACE FONT] Section
      5. [WORKSPACE FONT SIZE] Section
      6. [WRAP WORKSPACE LINES] Section
      7. [WORKSPACE COLORS] Section
      8. [RECORDING FILENAME PREFIX] Section
      9. [RECORDING PERIODS] Section
      10. [CHALLENGE REVERTING] Section
      11. [PRINTER FONT] Section
      12. [PRINTER FONT SIZE] Section
      13. [PRINTER PAGE SETTINGS] Section
      14. [LEFT TABS] Section
      15. [DEFAULT DIRECTORY] Section
      16. [FUNCTION KEYS] Section
      17. [TIMER SETTINGS] Section
      18. [PREMIUM SQUARE COLORS] Section
      19. [HOOK SEPARATORS] Section
      20. [PROBE ANSWERS] Section
      21. [BOGGLE] Section
      22. [BIG BOGGLE CUBES] Section
  29. Ending a WHAT Session
  30. Minimizing WHAT
  31. Glossary
  32. The Future

1.  History

This document describes the WHAT program Version 2.2 Build 96, which was released on the web on ??-Jun-16. To see the new and altered behavior of the program, see: WHAT Version 2 Release Notes.

WHAT has been in use in the Boston-area Scrabble® clubs since the Spring of 2004. Mike announced and demonstrated it in public for the first time at the 2004 National Scrabble® Championship Tournament held in New Orleans, LA in early August, 2004.

Mike first wrote the ANA program in the early 1980's, and, with years of its use, he came to want the program to be able to be more useful in answering queries which a competitive Scrabble® player tends to ask, either based on situations that arise in games or for the purpose of studying words in an organized manner. For the most common of queries, WHAT is used in much the same manner as ANA, but it has many new features that make it considerably more powerful.

1.1  Mike's Credentials

Mike Wolfberg is a highly experienced programmer, with several decades of software development experience. Mike's computer use began in the early 1960's, when he was an undergraduate student at M.I.T. After completing his B.S. degree, Mike continued his formal education at the University of Pennsylvania, where he received one of the early Ph.D.'s in Computer Science. Mike has been an expert Scrabble® player since 1980, and he attributes his fast rise to a high level of play to his use of computers, before they were so prevalent in the game.

WHAT is a relatively large program, initially designed, developed, and documented by Mike in about 1 1/2 years of intense work. Mike has supported and enhanced this program since then, often devoting his full attention to this project.

2.  WHAT Documentation

This user guide is not a tutorial with introductory examples, but an extensive reference document with details about the program. Early reviewers have indicated a preference for introducing the many features of WHAT through examples. At this time, there is a separate document entitled "WHAT Examples", and it is based on the TWL98 lexicon. It will eventually be updated to correspond with the OWL3 lexicon, which was adopted for use in North America starting in April, 2015.

It is our intention to write a series of introductory tutorials, and the first one of the series, entitled "WHAT's First", is a great place to begin to learn about the program. A couple of other tutorials have been written, to introduce the topics of flashcarding and the creation of study lists. Until more tutorials are available, please refer to this user guide to learn about all the features of WHAT. There is companion document to this guide, that is a reference for the WHAT command language; it is entitled "WHAT Command Language".

On-line help is also planned for the program, but it is not yet provided.

Although WHAT was produced especially for players of a popular word game played on a 15 x 15 board, it can be helpful for other word games and study. Some of the WHAT features are helpful for the 21 x 21 version of the 15 x 15 game, a 5 x 5 grid game, a 10 x 10 grid game in which letters can build upon other letters, and the game of Anagrams.

3.  Electronic Word Aid Features

If you are a first-time user, you may find it more comfortable using features of some electronic word aid devices with which you are already familiar. When WHAT first starts up, the workspace includes a short paragraph mentioning this, and you are instructed to look at the First Use tab to the left. On that tab there is a graphical button labeled "Enable Electronic Word Aid Features". Use the left mouse button to click on that graphical button, and you will cause the mostly blank contents of the First Use tab to have some instructions, a small display window, and five graphical buttons that emulate physical buttons on such devices. When typing letters on the keyboard, lowercase and uppercase letters are equivalent.

If you are not familiar with such electronic devices, you may as well proceed to using WHAT the way it is intended to be used; therefore, we will not go through a detailed description of the use of these features. We will at least point out these differences between WHAT and word aid devices:

Once you are familiar with the use of WHAT for anagramming and pattern matching, you will likely no longer want to employ these electronic word aid features. You can update initial settings so that one of the other tabs on the left is initially showing when WHAT starts up. It is recommended that you will make this be the Query tab instead of the First Use tab. On the other hand, if you want to run WHAT on a screen with a small pixel density, such as 800 x 600, it will run without the left tabs showing.

When using these word aid features, you will be seeing WHAT commands being constructed and performed for you. For example, if you are seeking words that end in AH from the letters EKNJSUH in your rack, the constructed WHAT command is:

   *ah,eknjsuh/Z/+B/<$$

In case you are curious, we will explain what this means. The comma separates the specified pattern from the specified rack. The pattern means that there can be any number of letters preceding AH in the sought words. These are the remaining command constituents:

/Z - score 0 for blanks used from the rack
/+B - a 50-point bingo bonus should be used for words at least 7 letters
/<$ - sort the presentation by decreasing order of scores
$ - include scores in the presentation of the answer

4.  Examples and Applicability

Here are a few examples to give you an idea of some of the kinds of word-game-oriented queries for which WHAT is applicable:

  1. With AEILNOS, is there at least one 7-letter word - "yes" or "no"?

  2. With AEFKNOT, what are the highest-scoring opening plays?

  3. With the rack ACILMT?, what are the possible triple-triple bingos through an R in the 4th character position? There is indeed one such word.

  4. What words have both a prefix of OVER and UNDER? Which words with a prefix of OVER do not have a matching UNDER word, and vice versa?

  5. What 8-letter words can be formed by adding an S to the front of a 7-letter word, such as SCATTIER? There are 383 such words.

  6. What are the 5-voweled 8-letter words that start with Z, such as ZOOMANIA? There are 5 such words.

So these are typical of the kinds of queries you will make using WHAT. You will be able to formulate some complex queries, such as the fourth example just given above. Here are some other examples:

  1. What are the 7-letter palindromes, such as REVIVER?

  2. What 7-letter words can be spelled backwards, including palindromes and non-palindrome words, such as GATEMAN?

  3. What are the 35 most-likely 7-letter words?

  4. What are the 35 most-likely 7-letter racks that have 7-letter words?

  5. What words that end in L lead to the same word extended to both LED and LLED, such as CANCEL?

  6. What words that end in INGS are not also words without the S, such as ABLINGS?

  7. How many bingos are there with LRAIOU?, and if any, what letters can the blank be, and then what is the first letter of each of the words, and then what are the words?

  8. Generate a random rack with a 50% chance of having a bingo, such as AEIORST. This particular rack has no bingos, but it is a likely one.

  9. What 7-letter words can be played above and parallel to RETAINS, also forming 7 two-letter words?

The document "WHAT Examples" document includes the command sequences which can be used to answer the above sample questions.

We could continue for quite some time with the presentation of examples, but what is here should serve you with the idea of what WHAT is for. You can use it as a situation analyzer, as a quiz producer, and as a word study tool. You can use it to help you develop study lists. WHAT is also intended to find steals when playing the classic game of Anagrams, where already-found words can be stolen by adding letters from the pool (or possibly other words) and rearranging. You can use WHAT as a way to look for the spelling of words you mostly know. It can be used to solve hangman-type puzzles, which also show up in crossword puzzles, but for crossword puzzles, capitalized words are often permitted as answers, and such words are missing from WHAT's current lexicons.

5.  Command Language Orientation

Graphical user interfaces (or GUIs) are often used to support programs like WHAT, where there are many options and many states. GUIs are especially useful for occasional users of such programs, but they are not as easy and quick to use to answer simple little questions, such as those that are expected to be asked of WHAT. Therefore, WHAT is designed with a more historically traditional command line interface as the fundamental method of making queries. A GUI is then used along with that to indicate what the program understands the queries to be. The GUI part of WHAT exists as an optional aid. You are also permitted to use menu picks and some GUI pointing and clicking to make queries, but these are likely to be more tedious than typing a few characters of the WHAT command language. The cost of this is that there are many WHAT commands, and learning how to use the tool effectively will probably take you longer than learning a GUI-oriented program. We believe the current command line philosophy is better matched to the needs of a frequent WHAT user than the typical GUI style of use.

When you begin to type a command, the GUI presents the state of the program as indicated by the long-term state of WHAT and then possibly modified for that query. As soon as you begin to type characters for a new command, the GUI presents the current state as indicated by long-term settings and perhaps altered by the current command, even as you are typing it.

The WHAT command language was designed intentionally to be succinct. It is therefore not easy for a person to decipher a command. The intention is that you can compose commands effectively, but you may find it difficult to look at a command and decipher what it means. The main reason for this is some characters in the command language are used for several different purposes. A left angle bracket is such a character. Because of this, WHAT may someday include a command report feature, so you can see what a command means in English.

6.  The GUI

Having just said that WHAT is designed to be used via your typed commands, WHAT provides a GUI that you can use both for input and output communication with the program. Since the command repertoire of WHAT is so extensive, when you are still inexperienced, you will likely find it helpful to indicate your intentions via using some of the GUI, as well as by typing command characters.

While constructing a command, if you alter the state of WHAT using GUI actions, equivalent command characters are inserted into the command line. Likewise, as you type characters on the command line, the line is scanned after each change, and the GUI represents WHAT's best interpretation of the current command. Errors on the command line may cause WHAT to stop scanning the line; but in the absence of errors, you can see how your command may be changing WHAT's state. Error diagnosis is not done until the command is terminated with the Enter key, which indicates the command should be performed. You can instead ask that the line be checked for errors without any action taken by holding down the Ctrl key while pressing the Enter key.

There are several characters in the GUI that are underlined, and such characters are called "accelerator characters". You can get to that part of the GUI by pressing the Alt key along with that character.

If a button has focus (i.e. WHAT is accepting your input in this place), you can see it highlighted, and then you can press the Enter key to have the same effect as clicking the button.

In menus, pressing the up-arrow and down-arrow keys will move you up and down. Similarly, if you are in a box that has a list of items, you can move up or down the list using the arrow keys. If you are at a check box, the space key can be used to flip between the states of checked and unchecked.

You are welcome to alter the height and width of the WHAT window, including maximizing it on your computer screen. There is a minimum size that you will be permitted to use for each of the dimensions. This minimum is still large enough so that all GUI controls remain visible on the screen. You may also adjust the font size of the workspace via the View menu when WHAT is freshly started. On the computer used to develop WHAT, the minimum workspace size is 15 rows by 51 columns when using the default font of "Courier New 16". With the window maximized, the workspace size is 30 x 89 using that font.

6.1  Workspace Size and Line Wrapping

The workspace window is main part of the WHAT window, where you type in commands and see results, primarily presentations of the slate. The workspace is arbitrarily long, and its width is settable.

You can clear the workspace either via a subcommand /CW or via clearing buttons available on the WHAT tab in the upper right of the WHAT window. You are likely to want to clear the workspace when you are preparing to print something. Printing in WHAT is done using the contents of the workspace.

The workspace window width has a particular value based on the size of the WHAT window. By default, the workspace width and the workspace window width are the same, since the width of the workspace is taken from the width of the workspace window.

You can see the width of the workspace on the Presentation tab on the left side of the WHAT window. Look for the box in the Layout section labeled Max Width. The default contents of this box is "workspace width". If you set the width to a particular number of characters, such as 80, it will show as "80 chars." in the box. To make such a change, you perform a command, usually a long-term one (see section "Short-term and Long-term States"), and the GUI can help you formulate the command via a dialog which comes up when you click on the ellipsis at the right end of that Max Width box.

When the workspace width is larger than the workspace window width, and when there are long lines, the workspace window will be scrollable. The only way this will happen is when you have chosen that long lines should not be wrapped. By default, lines longer than the workspace window width are wrapped to the next line (at spaces). You can control this via the View menu. If you have turned off wrapping, you can then get lines which are fully viewable only by scrolling.

Line wrapping is relevant only for lines which contain definitions, since otherwise, presentations are formatted such that they do not extend beyond the workspace width. There are two different widths which pertain: the workspace width and the workspace window width. Usually, these two quantities are the same, since by default the workspace width is set from the workspace window width. However, you may set to the workspace width to a specific number of characters or a specific number of columns.

The workspace window width is set indirectly based on the width of the WHAT window, and you are shown its dimensions at the lower right of the WHAT window. The wrapping of long lines is based upon the workspace window width. The formatting of slate presentations is based upon the workspace width. This distinction may be important for you to understand when you are preparing the workspace to be printed. Lines are printed according to how they are wrapped in the workspace. If a long line is not wrapped, or it is wrapped too far to the right, the printed form of that line cuts off near the right edge of the page.

On Mike Wolfberg's primary printer, using the default settings of 10 pitch Courier New font, and with the default left margin, a line is printed with 12 characters per inch, and so there is room for about 95 characters.

6.2  Menus

Although the design for WHAT features the use of a command language, the program also allows for your making menu picks in combination with typing keyboard keys to make up commands. If you are a new or occasional user, you may find this useful, but once you are a frequent user of WHAT, you are likely to formulate commands by typing commands on the keyboard only.

Words in the menus are underlined to show what accelerator keys you may type to select the menu items. These underlines do not show up in the menu until you press the Alt key.

We are aware that this user guide focuses on the command language, and it does not always mention how to use menu picks and other pointing and clicking to get WHAT to make up these commands. This deficiency may be rectified in the future.

6.3  Accelerator Keys

You can use the mouse to move and click to control the WHAT graphical interface, but you also have the option to press various keys while holding down the Alt key in order to make choices. One area where this can be used is in the menus. You can press Alt+<letter>, where <letter> is the underlined letter of one of the menu choices, usually the first letter; for example, you can pull down the Tools menu by pressing Alt+T. You can then continue to make further submenu picks in the same way; for example, you can press Alt+T, Alt+W, and Alt+C to bring up a dialog to copy items among wordlists.

The WHAT screen includes some underlined characters, and these are indicators of other accelerator key choices you have. For example, notice on the Query tab on the left side of the screen, there is an underlined S to indicate you want to filter by score.

6.4  The Tab Controls

The WHAT screen includes two regions where there are tabs on which you can click to see alternative graphical controls.

On the left side of the screen is a 3-tab control, where you have the choice of seeing electronic words aid features, query construction info, or slate presentation info. You can click on the tab to move to the one you want, or you have this other option: You can switch between the 2 latter tabs by pressing either Ctrl+Q or Ctrl+P. To return to the First Use tab, you must click on the tab itself.

The larger tab control in the upper right of the WHAT screen has 8 tabs. You can click on a tab to bring it up, or you can press Ctrl+\ to advance to the next tab. This key was chosen since it is in the upper right area of the keyboard, to match where on the screen the tabs are.

6.5  Fly-By Hints

If you would like to be shown pop-up hints as you move the mouse around the WHAT screen, use the menu pick View→Hints→On to enable these hints. If they are annoying you, turn them off. Hints are provided for many but not all of the graphical controls of the WHAT screen.

7.  Reading this Document

As with other powerful programs with many features, such as Microsoft Word, you can begin to use WHAT employing only a small percentage of its available features. As time goes on, you can explore more features, such as when you have something new to do. Reading through this entire specification is probably not a good way to become familiar with WHAT if you have never used it or its predecessor before. Coming back to reading parts of this user guide from time-to-time may prove useful, but it is probably too overwhelming to take in all there is to offer in one reading.

Many commands are described with specs, such as "<number>^", to indicate some number is to be supplied at that place in the command. These category names, such as "number", are enclosed within non-bolded angle brackets. In this document, angle bracket characters you are meant to type are shown in bold and are slightly larger (e.g. < >). Most of these category names are self-explanatory, and a few special categories are defined explicitly.

There is a "Glossary" section late in this document.

8.  Style of WHAT Use

In the workspace region, you interact with WHAT by typing command lines. WHAT prompts you to type a command line with:

WHAT?:
and the cursor remains on that line following one space as separator. You type some characters and then complete the command line by pressing the Enter key. WHAT then does something. It may not always do something you can see, according to what you have asked it to do in conjunction with short-term and long-term settings. For example, if you start to use WHAT and type the command line
   nrtaeei
followed by pressing the Enter key, you will be shown the answer:
ARENITE  RETINAE  TRAINEE
WHAT has shown you the words formable from the letters you typed by using all the letters. This is a prototypical example of what you as a user wants to know, and making a short query of typing just those letters is natural. There are many variations on this:

Rather than continuing to describe WHAT with examples in this document, we now describe the program in a more complete way to give you an understanding of what all the possibilities are for formulating commands. There is a comprehensive collection of examples is a separate document appropriately entitled "WHAT Examples".

If this is your first time reading this user guide, and if this is your first exposure to a description of the program, you are advised to set this aside now and read the "WHAT's First" document. That tutorial will provide you with enough knowledge to begin to make effective use of WHAT.

9.  Command Type-In

As you type a command line to WHAT, you have the ability to edit the line before submitting it for processing (i.e., getting performed). These editing characters are supported:



Backspace - at the command start, do nothing; otherwise erase the character before the cursor and move the cursor to the left by one character.
Ctrl+Backspace - erase one or more previous characters in the current command back such that what looks like the previous word is eliminated.
Delete - at the command end, do nothing; otherwise erase the character at the cursor and leave the cursor where it is.
Ctrl+Delete - erase all the characters in the current command and move the cursor to the position of the command start.
Insert - toggle between two modes of character input - inserting and overlaying.
Ctrl+Enter - check the current command and report any errors in the middle part of the status bar at the lower border of the WHAT window.
Ctrl+T - at the command start or end, do nothing; otherwise interchange the character to the left of the cursor with the character to the right of the cursor and then move the cursor to the right by a character.
Home - move the cursor to the start of the command.
Ctrl+Home - scroll the workspace to its beginning.
End - move the cursor to the end of the command.
Ctrl+End - scroll the workspace to its end.
left-arrow - at the command start, do nothing; otherwise move the cursor one character to the left.
right-arrow - at the command end, do nothing; otherwise move the cursor one character to the right.
Ctrl+A - select all text in the workspace.
Ctrl+B - same as left-arrow, Backup one character.
Ctrl+C - copy selected text (see below).
Ctrl+E - same as End.
Ctrl+F - same as right-arrow, go Forward one character.
Ctrl+V - paste text from the clipboard (see below).
Ctrl+X - cut (or copy) selected text (see below).
Ctrl+Z - minimize the WHAT window - this works even from within the Challenge Dialog.
F1 through F12 - function keys are used to input user-chosen character sequences. You can specify these assignments via a dialog available via the Edit menu, and initial values can be established in WHAT's initialization file. F10 cannot be used, since it selects the menu. Function keys represent text to be appended to the command line, and there are two options, whether to:
  • first clear the command line, and/or
  • follow the appended text with an automatic Enter key press to cause the command to be performed.

WHAT deals with selecting, cutting, and pasting, in conjunction with the Windows system clipboard. You may insert text only on the command line to the right of the prompt. If the cursor is elsewhere when you attempt to paste, it is first moved to the end of the command line. Inserted text must be all on one line. If the clipboard includes more than one line of text, only the text on the first line is used in the paste operation, and then any text following the end of the pasted first line is lost. If you attempt to cut text that is not all within the current command (following the prompt), a copy is done instead. One exception to this is if you include part of the WHAT prompt in what you are cutting; in this case, a cut is done, but it does not include characters from the prompt.

If your mouse or your computer has a mouse wheel, WHAT will respond to the wheel by scrolling the workspace. You can also use the scroll bars on the right edge of the workspace to do this.

9.1  Comment Commands

You may type double slash (//) on a line to cause WHAT to ignore the remainder of the line. In this way, you can type comments that have no effect on WHAT. This syntax is the same as introducing a comment in the C++ language.

9.2  Command History

Unless you intentionally clear it, WHAT retains a history of the commands you have typed in since starting up the program for its current session. Therefore, you can always go back and find a command you may want to resubmit to WHAT. There are facilities to see several of these commands at once, or you can bring back a specific command by its number. There are a few kinds of commands that are purposely not noted in the history. One example is the command to show you a random rack.

WHAT retains complete commands in its history, but the Command History area of the WHAT window, just above the workspace, shows beginnings of these commands, as much as can fit in the limited width area (which is not horizontally scrolled). If you select an old command from there via the pull-down menu, it will be placed into the workspace and it becomes the current command.

These command history keys and commands are not supported by menus and dialogs at the present time. This omission of low significance may be provided in the future. Please feedback any requests for this.

If you bring back a command, you are then able to edit it before pressing the Enter key to have it performed.

These are the keys and commands involving command history:

up-arrow - If you started typing a new command that partial command is not remembered, and then you are shown the previous command in the history. Subsequent uses of up-arrow continue to take you back to earlier commands, one at a time.

Once you are looking at the oldest command, another up-arrow has no effect.
down-arrow - Having pressed at least one up-arrow to see earlier commands in your command history, this character brings you back forward in the history list towards the present. Once you are looking at the most recent command, another down-arrow has no effect.
^<command-#> - When you give this command by itself at the start of the command line, WHAT brings back the command indicated by the number, and it becomes the current command, ready for possible editing or execution. If you intend to suffix a number on the end of the previous command in the history, separate the carat and the number with a space so it is not interpreted as this kind of command. This cannot be used in a command file.
^-<number> - When you give this command by itself at the start of the command line, WHAT brings back the nth most recent command, and it becomes the current command, etc. This cannot be used in a command file.
/H - show recent command history so that it almost fills the workspace; command numbers are included.
/<number>H - show command history beginning with the command designated by the given number and show as many commands going forward as almost fills the output area (if that many exist).
^ - use this character in a command to represent the text of the previous command, but this is not shown to you when you type the carat. However, if a command with a carat is performed, it is remembered with the carat replaced by the characters it represents. You can see that expanded executed command by looking at the Command History area above the workspace. If a command is brought back that had included a caret, the replacement will have been made. This cannot be used in a command file.
The above commands and keys are not noted in the history, and neither are empty commands. Commands are not inhibited from being in the command history on the basis of their causing errors or warnings.

There are more commands that involve command history described later in the "File Reading and Writing" section.

10.  Short-term and Long-term States

The state of WHAT consists of several criteria that affect how it carries out commands. Initially, there is a default state that applies, and you may indicate changes in various criteria both for the current command (i.e., the short-term) and also for the long-term. You may optionally follow parts of commands that affect the state of WHAT by an exclamation point to indicate the preceding command part not only affects the current or short-term situation, but it also applies to the long-term.

The GUI is helpful in showing the state of WHAT. At the beginning of a new command line, when WHAT has issued a prompt and you have not yet typed any part of a command, the GUI indicates the long-term state. As you begin to type a command, the GUI indicates the short-term state. Parts of the GUI are colored when changes are made. Yellow is used to show changes for the short-term (i.e., for the current command only), and green is used to show long-term changes.

11.  Canonical Ordering

A group of letters most commonly shows up in an order that forms a word, but there are some circumstances when you will prefer to see a group of letters in a canonical order. WHAT allows you to specify canonical orderings in a rather general way. You provide a string of characters that includes exactly one of each of the letters of the alphabet (of either case) and a blank denoted by a question mark. Your string may also include individual spaces or other separator characters. For example, our canonical ordering of choice is:

  BCDEFGHJKLMNPQRSTVWXYZ? AEIOU
and this causes a word such as ANISOLE to be presented in canonical order as: "LNS AEIO".

Use of uppercase letters is recommended, but not required, in canonical orderings. Especially since letter tiles in word games have the letters printed in uppercase, it will be a better visual match to use uppercase letters in canonical output. If you stick to uppercase letters in your chosen canonical orderings, WHAT also makes better presentations when canonical order output includes any letters that were specified as blanks. Specifically, letters based on blanks can be shown in green in the absence of any lowercase letters in your canonical order.

Here are some ideas for you in choosing your own order. You may wish to go in increasing or decreasing order by:

You may wish to separate some of these groups by spaces or a minus sign or some other character(s). If you intend to make and use flashcards, the best separators to use are spaces, since a canonically-ordered word is generally interpreted as a WHAT command when working with a flashcard.

Canonical orderings show up in two places in WHAT:

The special case of having no order is applicable only for the second situation, and in that case random order is used for the letters and blanks. The user-controlled orderings WHAT uses for these two situations can be set independently.

TBD: A while back, we realized there are two aspects of canonical ordering relating to what is on the slate and how the slate is presented. So slate output can have words or words canonically ordered. It is a separate matter how the slate is then presented. Canonical ordering can be used even if the slate has words on it. It would be redundant and of no meaning to have a slate with canonically ordered words and then ask to see the slate canonically ordered. At this point WHAT does not have commands to control each of these concepts.

12.  The Slate

The concept of a slate is specific to WHAT. It is virtual place within the program where query results are placed. You mainly interact with WHAT by issuing commands to it. A query is a specific kind of command that causes the program to output to the slate, typically replacing the slate contents by a new list of words. But some commands leave the slate alone and are either asking for some info about the slate or asking WHAT to do something else. WHAT includes the facility to save the slate to a wordlist for future use, but most often the slate keeps getting rewritten, as you continue to make query after query.

As a result of a making a query, the strings placed onto the slate are typically words in their correct (spelling) order. You can alter this so the words are placed onto the slate in the canonical order (of your choosing). These commands affect this:

/QW - do not create "semi-words" but real words (the default)
/QS - allow for the creation of strings (without the requirement they be words)
/Q;W - create "semi-words" rather than words, namely output words to the slate in canonical order
/Q;S - create "semi-strings", namely output strings to the slate in canonical order

As with the outputting of words, when the outputting of canonically-ordered words or strings is performed, duplicates on the slate are avoided.

When a semicolon (;) is included in a query the presentation of the slate contents is forced to be in canonical order, independently of what is on the slate at that time. That is, the slate may have words, canonically-ordered words, strings, or a mixture of these. The use of the semicolon to request the presentation is in canonical order affects each string on the slate, and so it is possible there will be duplicates within the presentation.

There are queries that can produce non-words when the [...] construct is involved, and then the /QS command may have to be used in order to retain all answers. Two-word anagram queries and two-word pattern queries necessarily result in strings.

Usually, the slate has words on it, but there is a way to get WHAT to have just letter strings on the slate. When the slate has words, it has zero or more words that are in alphabetical order. However, the presentation of the slate may reorder it for presentation purposes. This means that when you ask for the nth word of the slate, the answer is not dependent upon how you last saw the slate. Furthermore, a slate has at most one copy of any particular word.

Likewise, when the slate has strings on it, these are in alphabetical order, and there is at most one copy of any particular string on the slate at one time. These strings can include spaces, as is done for the output for two-word anagramming, two word patterns, and perhaps in canonical orderings.

There is a way to accumulate words on the slate, thus inhibiting WHAT from clearing the old slate when a new query is processed. This is specified with a command spec of /+S. Its opposite is /-S, which reverts to the default setting of slate clearing with each query.

The slate can be cleared by making a query (such as QQ) that results in nothing when query output replaces the slate (instead of augmenting it), and it can be cleared explicitly using the command /CS.

12.1  Categories of Slate Contents

The WHAT slate usually holds words which were placed there as a result of performing a query, but in general the slate can have other forms of content. WHAT categorizes the slate as holding one of the following forms:

Usually the slate is cleared before a query is performed, but you have the option of augmenting the slate when you make a query. In this rare case, the most recent augmenting query is used to set the category, despite the fact the slate may have a mixture of categories of items.

There is a command to clear the slate, and when you perform this command, WHAT (somewhat arbitrarily) sets the category to "words".

You can see which category pertains when you issue the number sign command to ask for how many items are on the slate. The answer indicates one of the above categories.

The category of the slate affects how anagrams are shown when you have specified you want to see anagrams in slate presentation. If the slate contains words, then when anagrams are listed, the word is not repeated within the parentheses, but for any other category of slate contents, all anagrams of the letters of the item are shown in parentheses.

13.  Commands and Queries

A query is a particular kind of command that causes some word list to be developed as a result of some specification of what letters are in the words. There are these kinds of queries:

and WHAT employs a query kind at any given time. You can set the default query kind, that starts out as "Anagrams", and the query kind can be temporarily set for a given query.

Letters usually represent themselves in queries, and thus for the specification of commands other than for queries, prefix characters are used to indicate a command is being given. Specifically, to change the kind of query to be a pattern, type /P, and when this is performed, this affects the current query only (i.e. it is for the short-term). If the command /P!, is performed, not only is the current query affected, but the default kind of query is also changed. This means that in the absence of another current or long-term query kind spec, subsequent queries are of the pattern type. The following of the command by an exclamation point is the way to express long-term settings.

You may precede a letter in a query (or in a set specification) with a number to indicate a repetition count. A set, word reference, or subword reference in a query may also be preceded by a repetition count.

You are not required to designate the letters used as the basis of a query sequentially. They may be interrupted by subcommands. For example,

   n(V)(V)/pn
means you want to see those 4-letter words that start and end with an N, where the two inside letters are vowels. The /p command to request a pattern match in the middle of the query letters is acceptable, but not recommended.

Notice the mentioning of matching vowels with the (V) command constituent in the above example. This is one example of the designation of a set of letters in WHAT. Some of these sets are predefined, such as (V), and you are given the power to define your own sets. Some sets are defined based on letters and other sets involved in the query. Sets will be described later in the "Letter Sets" section of this guide.

To change the kind of query, type one of these commands:

   /A   -   for anagrams
   /~A - for anagrams with blank circulation
   /P - for pattern matching
   /~P - for pattern matching with blank circulation
   /.P - for pattern matching with inserted blank circulation
   /+P - for pattern matching with additional blank circulation
   /S - for steals, as in the game of Anagrams
   /~S - for steals requiring base word rearrangement
   /I - for imbedded or included words
   /B - for 5 x 5 grid game solving
   /2A - for two-word anagrams
   /2P - for two-word patterns

When solving for the 5 x 5 grid game, a query must consist of 25 letters, and any provided rack characters are ignored. Perhaps sets and wild card characters will be supported for this in a future version of WHAT.

The /2A and /2P commands automatically imply the /QS command to allow for strings on the slate.

While typing a query, you may employ certain characters or character sequences that imply the query should be a pattern, in which case, there is no need to type /P, but it doesn't hurt. These are some of those utterances:

. - match any letter; this is a blank - the same as ?, except it implies the kind of query is pattern matching
* - match zero or more of any letters; this is a wild-card character, and it implies the kind of query is pattern matching
, - a comma separates a pattern spec and a rack spec; rack characters may follow the comma; typically you type the pattern, the comma, and the rack which is used to fill in blanks in the pattern.
[] - means a word from the current slate or given wordlist
[M] - means a word from the current slate or given wordlist mapped letter by letter
[<subword-spec>] - part of a word from the current slate or given wordlist
[M<subword-spec>]  - part of a word from the current slate or given wordlist mapped letter by letter
Any of these last four forms are called word references. A <subword-spec> can take various forms:
<number> - the nth letter
<number>-<number> - the mth through nth letters
~ - the reversed word
~<number>-<number> - the mth through nth letters of the reversed word
Also, | represents the word length. [<number>|] represents the nth letter from the end of the word, where 1 is the final letter, and so 1| also represents the word length. 2| represents the word length minus 1, and so [2|] denotes the 2nd last letter.

Although these query constituents imply a pattern query, that can be overridden by including /A on the line following any of these characters to indicate an anagram query is being made. It will often be the case that when you have a pattern query, you will use one of the above utterances, but there are exceptions; for example, you might ask for those words of length 8 whose letters alternate between consonants and vowels. The query would consist of built-in sets, and their inclusion in the query does not necessarily imply a pattern query. So, you would have to explicitly indicate this, such as by including /P in the query.

You may specify pattern queries by typing the pattern as the query string and then providing a rack of characters that can be used for blanks and sets within the pattern. Even if a singleton set is part of the pattern, the one character it can be must be found in the given rack. If you want a certain character at a certain position in the word, indicate it by itself, and don't repeat it in the rack. In other words, the rack is to provide those letters not already explicitly mentioned in the query string.

When processing an anagram query, WHAT ignores any rack characters that you have specified. This situation is somewhat unusual in that if you provide rack characters, the kind of query is set to pattern matching, and then you would have to provide an explicit override to set the query kind to "Anagrams", such as by including /A.

If you have a rack, such as ACILMT?, and want to know those words that have an R as the fourth letter, you could express a query as

   ...r....,acilmt?
The fact the R is in the pattern forces that fourth letter to be an R.

The example just presented has a length of query that is known and a number of letters in the rack to match the number of blanks in the query. In such a case, it is clear that all letters of the rack must be used. However, when there are more letters provided than required, not all letters mentioned in the rack need be in a matched word. To force WHAT to include a letter from the rack in a word, it should be followed by an exclamation point. When the lengths imply the need for all letters to be used, the forcing of a letter is irrelevant; in a sense, WHAT assumes forced letters were used.

When a query includes an asterisk or any other wild card query constituent (indicated by a repetition count of zero), any letters given in a rack may be required or not (according to how they are specified), and the rack is assumed to be filled out with as many blanks (or other wild card query character) as are required to match the query. For example, you could ask for those words that begin with a Q not immediately followed by a U that contains another U, using query:

   Q(!U)*,u!*

The asterisk is a wild-card specifier, and you will often employ this one in queries, especially pattern matching queries. It represents any number of any letters. WHAT supports a more general form of wild-card specifier that can represent any number of specified letters; for example, any number of vowels. This is indicated by employing a repetition count of zero as a prefix to a letter or set in a query. So the zero means "zero or more of the following letter or set".

Most kinds of sets are permitted in a rack, but query-based sets are not.

Word references are allowed within a rack. The rack is an unordered set, so reversed words and subwords can be expressed, but the reversal has no effect.

Characters in a rack must immediately follow a comma and not include spaces. The first space you present within your specification of the rack terminates the rack, and further characters you type are taken to be query characters. You may provide further rack characters within the query by tying another comma.

If you not explicitly set the kind of query, but you include a word reference, the query is kind is defaulted to be a pattern match, but if you then include either a plus sign or minus sign, that changes the query kind to "Anagrams". So, if you have a slate of words resulting from a query other than an anagram query, you could perform either of these commands

   []-
   []/A
to see those words along with their anagrams.

13.1  Errors and Warnings

This section needs updating, now that the GUI is involved, etc. Thus we indicate it is To Be Determined (subsequently abbreviated as "TBD") in this guide.

When you end a command with Shift+Enter, WHAT will check that command, but not perform it. When you end a command with Enter, WHAT will first check the command, and either report detected errors, or it will perform the command in the absence of errors.

As you type a command, the WHAT GUI indicates the meaning of the command in the current context of the program, but the checking for errors and conditions worthy of warnings is delayed until you finish the command and press the Enter key. At this point, if anything is wrong, WHAT comes back with a line starting with " ERROR - " and followed by a short explanation of the first error it noticed. Some legal parts of the command already scanned may have led to the program's carrying out some work. Upon encountering a part of a command line in error, WHAT ignores the remainder of that line.

Two conflicting specifications in a command are generally accepted and not considered as an error. The most recent spec overrides an earlier one. For example, if a command includes both an apostrophe and a quotation mark, the last one in the command pertains.

13.2  Letter Mapping

The feature of letter mapping is a somewhat obscure facility provided for unusual, non-typical queries.

Word references that begin with the letter M (or m) following the left square bracket indicate that each letter coming from the word or string is to be mapped to a letter based on a user-specifiable mapping. For example, one form of word reference may involve the mapping of one letter to another; this is for a word reference of the form

   [M<number>]

This means to get the nth letter of a word from the slate (or whatever the current source of word references is) and map that letter to another letter.

WHAT supports one map at a time, and these are the related commands:

/M"<26 letters>" - set the letter mapping
/M? - show the current letter mapping

When WHAT starts, it has a default mapping of "BCDEFGHIJKLMNOPQRSTUVWXYZA".

The first letter in the mapping indicates the letter A maps to, the second letter in the mapping indicates the letter B maps to, etc. It is not required that the 26 letters in the mapping are all different. There is a menu pick Query→Word Reference Letter Mapping... to bring up a dialog to help formulate a mapping.

13.3  One-Letter Commands

In general, one letter on a command line appears to be a query with only that one letter, and since there are no 1-character words in WHAT's lexicons, this is never going to lead to any results. Therefore, some individual letters are used for some of the most common commands:

C - bring up the dialog to handle challenges.
D - delete the current flashcard.
F - present the most recent flashcard again.
G - bring up the 5 x 5 Grid Game Player Dialog.
M - bring up the dialog for deleting, copying, or moving wordlist items.
N - when doing randomized flashcarding, first put the current flashcard at the end of the group, assuming the toughness is zero. Then present the next flashcard; this is equivalent to a command of the number zero only when doing randomized flashcarding. When doing sequential flashcarding, the card is not moved using this command, but it is moved for the toughness of zero command.
P - bring up the 15 x 15 Grid Game Player Dialog.
R - produce a random rack as a command, but do not perform that command; the command of one period does the same thing, except it does then perform the command.
S - bring up the 21 x 21 Super Grid Game Dialog.
T - show the Timer tab and start the WHAT timer.
X - move the current flashcard to the next wordlist.
Y - move the current flashcard to the wordlist after the next one.
Z - move the current flashcard to two wordlists after the next one.

More of these 1-letter commands will likely be made available in WHAT, as needs are noticed during WHAT use.

13.4  Query Constituents

The main part of a query consists of any of these query constituents:

For any of these, you may give a prefix repetition count. When the count is zero it means zero or more of that constituent, so it is a wildcard specification. A zero count for a word reference has no well-defined meaning; this detail of WHAT deserves some further investigation [TBD]; until this is better understood and described, you are encouraged to avoid this construct in queries. A suffix of an exclamation point may follow any of these to indicate the letter(s) represented by the constituent must appear in the result.

13.4.1  Query Character Specifications

The above section introduced some of the character specs that you may include in a query. This section introduces more of such specs. The simplest and most common query character is a letter. This just means the letter is part of the sought word. When the query is an "Anagrams" kind of query, that letter may appear anywhere within the word.

You can specify a blank in either of two ways:

? - this is the usual blank, one used in anagramming, and if blank scoring is being done, it scores what the letter it represents scores, as long as the bag has enough of that letter.
. - this is the same as the ? blank, except that a pattern query is implied by its inclusion in the query, as described in the previous section.

Another powerful character spec that is supported by WHAT is a set of characters. A blank is a special form of a set in that it can represent one of any of the 26 letters of the alphabet. Other sets may also be useful in formulating queries. The later "Letter Sets" section covers sets.

13.4.2  Subtracting Query Letters

Characters represent themselves in queries, and the usual kind of query WHAT supports is an "Anagrams" kind of query. For anagram queries, you may specify some letters and then specify letters that you want to be eliminated. Type a minus sign to introduce letters you want to remove. An example is the query:

   unitedstatesofamerica-underestimates/|4
that requests the words of at least length 4 that can formed from the letters left over when you eliminate letters in "underestimates" from those in "unitedstatesofamerica".

You may use a plus sign to introduce more query letters to be included following a list of removed letters.

It is permissible to subtract too many of a letter such that the count for that letter goes negative, in that case WHAT assumes it to be zero.

Subtraction of letters is permitted for pattern matching queries only in the rack.

13.4.3  Circulating the Blank

This unusual and powerful kind of query can be done for either anagram queries or pattern queries. Furthermore, with pattern queries there are three cases:

For the first of these three cases, WHAT replaces each of the unrequired letters in the query with a blank. It does not replace blanks or sets or required letters of the query. This is appealing to use with anagramming to yield study lists; such words have been coined as "blanagrams" by others.

Recall that you specify a required letter by following it with an exclamation point.

Circulating the blank with pattern matching can be interesting in that you are shown closely related words. For example, if you make the query:

   baboon/~P
these words result:
BABOOL   BABOON   BABOOS   GABOON
As mentioned above, the blank may be circulated for a pattern query such that it is inserted to the left or right of each character, instead of in place of the character, possibly skipping such an addition at the head or tail. For example, this query:
   senor/.P
yields these words:
SENHOR   SENIOR  SENSOR
This similar query:
   senor/+P
yields these words:
SENHOR   SENIOR  SENORA   SENORS   SENSOR

13.4.4  Steals

The query kind known as "Steals" is provided especially for finding word steals when playing the game of Anagrams. The letters you provide in a steal query must all show up in the answer. A minimum number of blanks are added to the query letters to yield the shortest word. If blanks are part of the query they represent excess above the minimum. Thus,

   /~Sumiaq
yields an answer of  MAQUIS, and
   /~Sumiaq?
yields an answer of : MARQUIS, whereas
   /~Smaqui?
yields an answer of 7 words including  AQUARIUM.

This might be a bit confusing. The base word of  MAQUI has a 1-letter steal when requiring base word rearrangement, that is  UMIAQS. If you then seek a steal with 2 letters requiring rearrangement it turns out that there are no 2-letter steals with a rearranged answer - the only 2-letter steal of  MAQUI is  MARQUIS, and there is no rearrangement. When requiring rearrangement for this case, a 2-letter steal request answer consists of those words with 3-letter steals.

Queries for steals are limited to letters, blanks, and whole word references; they may not include wild characters, sets, or partial word references. This restriction could probably be lifted; please let us know if you have such a need.

13.4.5  Two-Word Anagramming

The ability to perform 2-word anagramming is probably not of any use for most word games, but this feature is included in WHAT since this kind of question does arise on occasion. Especially when many letters are provided as the basis of the query, the number of answers can be extensive. For this reason, WHAT will not accept a two-word anagramming query that includes any blanks.

WHAT supports two-word anagramming only for explicitly provided letters. Blanks, sets, and wild-card characters are not supported in two-word anagramming at present.

In the answer to a two-word anagramming query, no duplicates are produced, but all anagram variations are included. So if CAT is part of one pair of words in the answer, there will be another answer with ACT in the same place.

Individual words which are part of the answer to a two-word anagram query are never marked with an indicator to show that the word is from a particular lexicon. This is also the case for two-word pattern queries.

The slate holds the answer to a two-word anagram request with one space separating the two words, and the words are in alphabetical order. When the slate is presented, WHAT is aware that it was created as a result of a two-word anagram query, and therefore is determines the longest first word, and then presents the slate with one word pair per line and so that the second words of each answer line up in the same column.

13.4.6  Character Conventions

This section describes how you use each of the characters of the keyboard within WHAT commands. The order of this section is based on the order of ASCII numerical encoding.

Individual keyboard characters other than digits and letters are employed as common constituents of commands. Less-used command constituents are expressed using multi-character sequences.

<tab> - The Tab key can be pressed to terminate a command line which has one or more words to be challenged. The Challenge Dialog is brought up, primed with any comma-separated words on the command line.
Esc - The Esc key can be pressed to terminate a query which is taking too long or a slate presentation which is more than you want to see. It is used other than during the processing of a command to alternate between the Challenge dialog and normal WHAT use.
<space> - Spaces terminate subcommands. They are usually optional. A space ends the specification of rack characters (introduced by a comma).
! - The exclamation point is used in these ways:
  • as the first character of a command line to indicate you are reusing the most recently used query and rack specification
  • as a prefix character in the specification of a specified set, where it means "not"
  • as a prefix character in the specification of filtering according to definition contents to indicate you are filtering based on a string's not being in a definition
  • as a suffix character in a query to indicate the previous query constituent is required to be in the result
  • as a suffix character following a command or subcommand to indicate that command or subcommand is to have a long-term effect, as well as a short-term effect
  • in relational operators.
" - The quotation mark (or double-quote) is employed in commands to indicate words are to be presented one per line, each with its definition. When a word has more than one definition, a plus sign is used as a separator instead of the usual minus sign; when the presentation layout is not set to one word per line, all definitions of the word are shown in the presentation on subsequent lines. This feature is available only when you supply WHAT with a suitable definitions file. Quotation marks are also used within commands to enclose labels, indicate the print job title, and specify a lexicon using its short name.
# - The number sign (also known as an octothorp) is employed in commands to mean "number of words". When it is used alone, it indicates the presentation of the slate is limited to indicating the number of items on the slate. It is also used within the specification of built-in sets, where it means letter frequency (i.e., "number of letters") in a game played on a 15 x 15 board.
$ - Dollar sign is used to specify something connected with the scoring of a letter or a word.
% - The percent (that anagrams to PRECENT) sign is used to specify something connected with word probabilities.
& - The ampersand is used in a couple of ways:
  • to represent the number of anagrams; this shows up in query filtering, slate presentation, and sorting;
  • as the operator for set intersection, used for wordlists and letter sets.
' - The apostrophe (or single-quote) is employed in commands to indicate words are to be presented in the order they are on the slate. This is typically in normal word order, but you can alter query results to yield other ordering.
( - The left parenthesis (that anagrams to FELT INTERPHASES) is used as part of the specification of letter sets and to introduce a reference to a letter set.
) - The right parenthesis (that anagrams to GIRTH/GRITH INTERPHASES) is used:
  • as part of the specification of letter sets and to terminate a reference to a letter set;
  • to indicate slate presentation includes anagrams.
* - The asterisk (that anagrams to SARKIEST) is used in queries to mean zero or more blanks. Although when it is used a pattern match query is implied, you can change that so that an anagram query is done, in which case it means any number of blanks can be used. It is an error to include redundant asterisks in a query, such as consecutive ones. Consecutive periods and asterisks are permitted. This character is also used to specify a set operation of cross-product which produces a new wordlist based on two existing wordlists.
+ - The plus (that anagrams to PULS) sign is used in some commands, such as the /+S command. It is also used in queries to terminate a list of subtracted letters and then revert to indicating letters included in the query. Another use of the plus sign is as part of the specification of a set indicating a letter already in the word.
, - The comma is used only as an optional character in the /OR command to indicate a comma is employed as a separator when slate output is in packed rows. It is also used to introduce the rack in a query. Typically you type the pattern, the comma, and the rack which is used to fill in blanks in the pattern.
- - The minus (that anagrams to MUNIS) sign is used for many different purposes:
  • as a prefix for command phrases to turn something off involved with the slate presentation, such as the showing of scores (-$);
  • in the /-S command;
  • as a one-character command to output a line of minus signs, which is treated as a page break when the workspace is printed;
  • as a hyphen when specifying a range of values;
  • as a hyphen when specifying a range of letters in a set;
  • to indicate vowels are to be ignored when filtering for what the blank can be;
  • to represent the set difference operator when declaring a user-defined set based on the difference between two sets;
  • to represent the wordlist difference operator;
  • used in a query to indicate letters that have already been specified but are being subtracted from the query. An example is:
       unitedstatesofamerica-underestimates/|4
  • as part of the specification of a set indicating a letter not yet in the word.
. - The period (that anagrams to DOPIER) is used in queries to mean a blank, but also the query is implied to be a pattern match kind of query. A period-specified blank, like a question mark one, normally scores according to the letter for which it is used in a word; whether it does is under your control using the /Z and /-Z commands.

A command consisting of just a period causes a random rack to be generated and it replaces the command line.
/ - Slash is employed to introduce most of the WHAT commands and subcommands. It is also used when probing the slate as a separator between character number and item number, either of which you may omit.
<digits> - Digits are used to express numbers, and these are employed throughout the WHAT commands to provide values. A number can precede a letter in a query to indicate a repetition count. Also, /2A and /2P specify kinds of queries.
: - The colon is used to represent the presentation of the slate is to be based on what the blank can be. It is also used to specify sorting based on what the blank is. It is used as a separator when specifying an item of a wordlist in commands to delete, copy, and move items, and also to start up sequential flashcarding.
; - The semicolon is used to refer to canonically-ordered words. You may create the slate with canonically-ordered words. As a separate step, you can have the slate presented with words in canonical order. Canonically-ordered words are in general non-words; you can think of these as "semi-words", hence the choice of using this character for this purpose.
< - The left angle bracket is used to specify something connected with front hooks. It is used to specify decreasing sorting order. It also shows up in relational operators, where it means "less than". It is used in ranges where the range is not inclusive of the upper extreme.
= - The equal sign is used in a few different ways:
  • to indicate the presentation of the slate is limited to indicating those letters exactly one or two blanks represent in the most recent query (ignoring 5 x 5 grid game and two-word anagramming queries);
  • in commands to indicate certain sorting is not to be done;
  • as an assignment operator character; these uses include declaring a user-defined set, yielding user-defined sets, and setting values of WHAT variables;
  • (=) represents the ever-changing built-in set based on the possible letters the blank can represent in the most recent query when that query had exactly one blank (ignoring 5 x 5 grid game queries);
  • this shows up in relational operators.
> - The right angle bracket is used to specify something connected with back hooks. It is used to specify increasing sorting order. It also shows up in relational operators, where it means "greater than".
? - The question mark represents a blank in a query. Like a period-specified blank, it usually scores according to the letter for which it is used in a word, but you may indicate blanks are to be zero-scoring using the /Z and command. It is also part of commands for word presence in a lexicon or wordlist.
@ - The at-sign (that anagrams to GAINST/GIANTS/SATING) is used:
  • to specify something connected scoring based on board positions. If it is followed by a tilde, the position must be within the word. Without the tilde, the word must start at the given position.
  • to indicate a set in a query that denotes all the members of the set, as if they were supplied explicitly.
<ABC...> - Uppercase or lowercase letters represent themselves in queries; case of letters is of no significance. Letters of either case are also usable as part of many different WHAT commands.
[ - The left square bracket is employed in a query to introduce a reference to a word already on the slate or some list. The reference may be for the whole word or some part of it, namely a subword.
\ - Back-slash is employed in commands to mean nothing about the slate is presented as a result of making a query.
] - The right square bracket is used:
  • in a query to terminate a reference to a word already on the slate or some list. The reference may be for the whole word or some part of it, namely a subword.
  • to specify slate presentation is done with hidden words, such that each word is merely shown as "[]".
^ - The carat is employed in commands to refer to commands already issued and thus exist in the command history. Its use is not supported in command files.
_ - The underscore is currently an unused character is WHAT.
` - The back apostrophe (or unquote) is employed in commands to indicate words are to be shown with what letters can be unhooked, namely whether a leading or final letter (or both) of a word can be dropped to form other words.
<abc...> - Lowercase or uppercase letters represent themselves in queries; case of letters is of no significance. Letters of either case are also usable as part of many different WHAT commands.
{ - The left curly brace (that anagrams to ACERB/CABER) is used in WHAT to introduce a set of letters whose probability is to be computed.
| - The vertical bar is used to specify something connected with word length. It is used as part of commands to affect sorting by word length and presentation of word length. It is also used within subword references (within square brackets) to indicate the number of letters in the referenced word and also some number of letters related to the referenced word's end. It is also used as the operator for set union for wordlists and letter sets.
} - The right curly brace (that anagrams to ACERB/CABER) is used in WHAT to terminate a set of letters whose probability is to be computed.
~ - The tilde (that anagrams to TILED) is employed in various ways:
  • as a kind of query, it alone means the only presentation of the slate is whether or not the slate has at least one item;
  • following slash and at-sign, it indicates a board position that is involved as part of scoring words;
  • indicates blank circulation in query kinds;
  • indicates requiring word rearrangement in steals;
  • indicates reverse order in word references;
  • sort the slate according to presentation sorting when the slate is copied to a wordlist;
  • indicate randomized flashcarding in the /<#>~FC command.

13.5  Letter Sets

A letter set, which we will merely call a "set", consists of any number of each of the 26 letters of the alphabet, except an empty set is not allowed. Usually, each set, either built-in or user-defined, has at most one of any given letter, but this is not required; letter counts in a set may exceed one. This is useful in some uses of letter sets.

In the dialogs to define a user-specified set, there are options to:

The third option can be useful when typing a phrase or sentence and ending up with the letters used at at value of 1 instead of the number of times the letter appears. This is useful when creating anamonics; if you don't know this term, see the Glossary at the end of this user guide.

To include a set in a query, a set specification is used; these set specs always begin with a left parenthesis and end with a right parenthesis. Some of these enclose something as brief as one character.

You may use some kinds of set specifications only in queries.

There are several kinds of letter sets:

13.5.1  Built-in Sets

(A)
all letters of the alphabet
(B)
the 98 letters in a full bag of tiles, excluding blanks; you may redefine this set, but you must include at least one of each letter
(C)
all consonants, including Y
(C-)
all consonants, excluding Y
(P)
the 196 letters in a full super bag of tiles, excluding blanks; you may redefine this set, but you must include at least one of each letter
(V)
all vowels, excluding Y
(V+)
all vowels, including Y

In the above several set specifications, you may use either lowercase or uppercase letters within the parentheses. It is easier to type uppercase letters, since parentheses are shifted keys.

($<number>)
letters whose scores are at least this
($)
scores for each of the 26 letters; you may redefine this set
($<number>-<number>)
letters whose scores are in this range
($<number><<number>)
letters whose scores are in this range
($<rel-op><number>)
letters with certain scores where "<rel-op>", that means relational operator, is one of these characters or character pairs:
   = == ! != > < >= <=
Either one or two equal signs means a test for equality (the double form may be preferred by C programmers), exclamation point means "not", and either ! or != means "not equal". For example, ($5) or ($>=5) means the set of letters whose scores are at least 5, namely: J, K, Q, X, Z.
(#<number>)
letters whose counts are at least this
(#<number>-<number>)
letters whose counts are in this range
(#<number><<number>)
letters whose counts are in this range
(#<rel-op><number>)
letters with certain counts or frequencies where "<rel-op>", meaning relational operator, is one of these characters or character pairs:
   = == ! != > < >= <=
Either one or two equal signs means a test for equality (the double form may be preferred by C programmers), exclamation point means "not", and either ! or != means "not equal". For example, (#6) or (#>=6) means the set of letters whose counts are at least 6, namely: A, E, I, N, O, R, T.
(=)
blank-representing set, defined when the previous query had one blank.

The blank-representing set is a set with a dynamic meaning, namely, its value is based on the most recent query. When mentioned in a query it refers to the already-completed previous query and not the current one. It can be referred to after the query is complete. When the most recent query had no blanks or if blanks could not represent letters, then this set is empty. Generally, sets in WHAT are not empty, but this one is an exception.

The blank-representing set includes one each of those letters for which any of those blanks in the query can represent. The wild-card character * is not considered as a blank for this purpose. The blanks that do count are denoted by . or ?.

13.5.2  Word-based Sets

A set of letters can be expressed by which letters a particular letter may be in a word or what letters can be added to a set of letters to form a word, given that word's other letters. For example, one might express a word-based set as those letters that can be the second letter of 3-letter words that begin with T and end with N. These sets are specified by enclosing within the parentheses at least 2 characters, such that exactly one of them must be a period and others must be letters (of either case); the example, just mentioned would be:

   (t.n)

There is a second flavor of word-based sets that is a generalization of the use of a word with one period, and that is the use of a set of letters with one question mark. The set consists of those letters which that blank (denoted by the question mark) can represent such that there is at least one word with those letters. For example (ZOA?) represents the set with the letters E and N. It does not matter in what position the question mark is or where the letters are.

13.5.3  Specified Sets

(<letter-list>)
indivudal letters or letter ranges, such as A-E, in any order, perhaps with repetition counts and/or duplicates
(!<letter-list>)
all letters other than ones in this list; duplicates in this list are ignored, and repetition counts are not permitted here

In these specifications, you may type letters in either case. You may precede a letter in a letter list by a number to indicate a repetition count greater than zero, but not in the final form above. There are many ways to specify the same set; for example, (#6) can also be denoted by (aeinort).

Single letters within parentheses have a special meaning, and therefore that is an unrecommended form in which to express a singleton set. In the instance where you want to be sure you are denoting a singleton set, precede the letter by a repetition count of one. However, WHAT will interpret (<letter>) as a singleton set if there is no other meaning for it.

13.5.4  User-Defined Sets

When you plan to use a set more than once, or if you want to specify a set based on other sets using set operations (union, intersection, or set difference) you should declare a user-defined set. These user-defined sets are then referenced by a number less than 100. When you specify one of these sets you may optionally provide a label to help you to remember its purpose.

To declare a user-defined set, use one of the following forms of commands:

When the optional set number (/<opt-set-#>) is omitted, the lowest number not currently in use for a user-defined set is employed.

When the optional set is specified as empty, the set is removed; sets may not be empty. When the optional set is present, it can be represented by one of several possibilities for "<set>" described in the previous section.

When all of the optional parts of the command are omitted, WHAT presents a listing of all the user-defined sets. If you provide only a label, nothing is done, but it is diagnosed. If you supply a label when you are removing a set, WHAT ignores the label, and it makes no error diagnosis.

For the final three command forms, "<set>" represents either:

Since letter sets may have more than one instance of any given letter, the meanings of these set operations are not traditional. When taking the union of two sets their counts are added. When taking the intersection each letter's count is the minimum of the two counts of that letter. Set difference is done by subtracting the counts of the second set from the counts of the first set, yielding counts that are no less than zero.

A user-defined set is referenced with its set number within parentheses, namely: (<number>)

13.5.5  Query-based Sets

Query-based sets are ones that can be used in the construction of pattern-matching queries, whose meanings are based on the current query. These sets are merely singletons (with one letter) since they refer to a specific letter already in the word being matched against the query. These are the possibilities:

(+)
for a repeated letter - one already in the word
(+<set-spec>)
for a repeated letter that is also in the given set
(R<number>)
repeat the nth letter of this word
(R-<number>)
repeat the nth previous letter of this word
(-)
for a first-time letter - one not yet in the word
(-<set-spec>)
for a non-repeated letter that is also in the given set
(S)
same set as the set used for the 1st character of the query
(S<number>)
same set as the set used for the nth character of the query
(S-<number>)
same set as the set used for the nth previous character of the query

For the two R- forms and three S- forms, the "<number> must be greater than 0.

Except for these last three forms, when you present the same set twice in a query, each set is separately full. But for these same-set references, as each letter is matched from the set, one of those letters is removed during the query. An example, is the query

   b(V)b(S2)
that produces answers BABE, BABU, and BUBO, but not BABA, since the A was already used in the second position.

Query-based sets are usable only within the query part of a pattern-match query. They are not supported in a rack.

13.5.6  Set Contents

In a query, you may specify a set with a leading at-sign following the left parenthesis. This denotes that all members of the set are to be included in the query, as if they were supplied explicitly. This kind of set specification makes little sense in a pattern-matching kind of query, so it is not allowed there, except, perhaps, in the providing of a rack. For example, in a query:

   (@V)
specifies that all of the vowels are included (once) as query letters. This is equivalent to having typed:
   AEIOU
This kind of specification can be combined with set specs that begin with a plus or minus sign. The at-sign must come first.

13.5.7  Examining Sets

You can ask WHAT to indicate the members of a presented set. You do this by merely naming one set as a command. You may also ask to see all the user-defined sets with the command:

   /U
WHAT presents these one per line using the format of: set number followed by the label followed by the set contents. If a letter is repeated in a set, a count is given before the letter.

13.5.8  Redefining Set (B)

The set denoted by (B) is a built-in set of the 98 (or 100 for French) letters/tiles in the bag. You may adjust the set's definition, but you must include at least one of each letter. This is the form of the subcommand to change the meaning of (B):

/(B)=<a set, enclosed in parentheses>

When this subcommand is on a line, the changing of set (B) happens after all other subcommands are performed, no matter where on the line this is. This command therefore takes effect for the long-term only; therefore, it is optional to follow it by an exclamation point, which is required for other subcommands that are either short-term or long-term to indicate a long-term change is to be made.

Changing set (B) does not affect the tile distribution used in the Word-Building Game.

If you make a change to set (B), it is forgotten if you then change lexicons to one of a different language.

13.5.9  Redefining Set (P)

The set denoted by (P) is a built-in set of the 196 letters/tiles in the super bag. You may adjust the set's definition, but you must include at least one of each letter. This is the form of the subcommand to change the meaning of (P):

/(P)=<a set, enclosed in parentheses>

When this subcommand is on a line, the changing of set (P) happens after all other subcommands are performed, no matter where on the line this is. This command therefore takes effect for the long-term only; therefore, it is optional to follow it by an exclamation point, which is required for other subcommands that are either short-term or long-term to indicate a long-term change is to be made.

Changing set (P) does not affect the tile distribution used in the Word-Building Game.

If you make a change to set (P), it is forgotten if you then change lexicons to one of a different language.

13.5.10  Redefining Set ($)

The set denoted by ($) is a built-in set representing the scores for each of the 26 letters (or 28 tiles for Spanish). You may adjust the set's definition. This is the form of the subcommand to change the meaning of ($):

/($)=<a set, enclosed in parentheses>

When this subcommand is on a line, the changing of set ($) happens after all other subcommands are performed, no matter where on the line this is. This command therefore takes effect for the long-term only; therefore, it is optional to follow it by an exclamation point, that is required for other subcommands that are either short-term or long-term to indicate a long-term change is to be made.

Changing the letter/tile values affects the scoring in the Word-Building Game, but the tiles shown have the standard scores on them.

If you make a change to set ($), it is forgotten if you then change lexicons to one of a different language.

13.6  Wordlists

WHAT provides for saving and restoring lists, especially from and to the slate. The slate is where output from queries is accumulated, and you may save the contents of the slate for various reasons. These saved word lists are termed "wordlists", despite the fact that the items in a wordlist need not necessarily be words. Wordlist items are in general strings of printed characters and spaces.

Wordlists are designated by numbers less than 100, and wordlist 0 is the slate. You may associate a label with a wordlist, as an aid for remembering its purpose. The slate's label is "Slate", and you cannot change it. Except for the slate, wordlists cannot be empty. When you attempt to make an empty wordlist, that wordlist is eliminated.

These are command that deal with wordlists:

/W<opt-label> - save the slate to a wordlist with the lowest unused wordlist number
/<wordlist-#>W<opt-label> - save the slate to a wordlist of the given number
/<wordlist-#>~W<opt-label> - save the slate to a wordlist of the given number, sorted according to slate presentation sorting

When a slate-saving command is used as part of a query, the saving takes place after the answer has been accumulated on the slate.

/R - restore the slate from the most-recently created or updated wordlist
/<wordlist-#>R         - restore the slate from the given wordlist

When a "restore" command is used as part of a query, the restoration takes place before the query begins; this makes sense only when a query is the kind where the old slate provides words, since otherwise the operation has no effect.

/<wordlist-#>D - delete the given wordlist
/<wordlist-#>L<opt-label>   - associate the given label with the wordlist; if you supply no label, WHAT eliminates any existing label. You cannot alter the label of the slate; it is fixed at "Slate".
/<wordlist-#>S - shuffle (i.e., randomize or mix-up) the order of this wordlist - useful for flashcarding

These "yield" commands perform wordlist-combining logical operations:

/Y<to-wordlist-#>=<from-wordlist-#> - copy a wordlist, indicating an error if the from-wordlist does not exist
/Y<wordlist1-#>=<wordlist2-#>|<wordlist3-#> - yield the union of the wordlists
/Y<wordlist1-#>=<wordlist2-#>&<wordlist3-#> - yield the intersection of the wordlists
/Y<wordlist1-#>=<wordlist2-#>-<wordlist3-#> - yield the difference of the wordlists
/Y<wordlist1-#>*<wordlist2-#>-<wordlist3-#> - yield the cross-product of the wordlists, which means every word from wordlist2 is concatenated to every word from worlist3
In the first three of the above four operations, <wordlist2-#> and <wordlist3-#> must differ, but one of these may match <wordlist1-#>; in such a case, WHAT does not issue a warning. WHAT reports the number of items in the output wordlist.

When computing the union of two wordlists, the resulting words have lowercase letters where that letter is lowercase in either of the source wordlists.

You may have WHAT append an aribtrary line of text to a wordlist. This may be helpful when creating files to be used for flashcarding or for the creation of WHAT command files. The command to do this is of the form:

/><wordlist-#>A<line-of-text> - append the line of text to the specified wordlist, omitting the command itself from the slash through the A
When you use this command, WHAT does not avoid having duplicates in a wordlist.

You can ask WHAT to report on the existence of all wordlists:

/L - see all the wordlists other than the slate in a report with one wordlist per line, where these are shown: wordlist number, label, number of items

See the "Source of Input for Queries" section later in this user guide, where there is a description of how a wordlist can be the source of input for a query.

13.6.1  Moving Items Among Wordlists

These are the commands for moving items among wordlists:

The first 4 of these are especially short for working with flashcards:

X - as a 1-letter command, move the flashcard to the end of the wordlist whose number is one higher than that of the wordlist being used for flashcarding, and prompt with the next flashcard
Y - as a 1-letter command, move the flashcard to the end of the wordlist whose number is two higher than that of the wordlist being used for flashcarding, and prompt with the next flashcard
Z - as a 1-letter command, move the flashcard to the end of the wordlist whose number is three higher than that of the wordlist being used for flashcarding, and prompt with the next flashcard
D - as a 1-letter command, delete the current flashcard, removing it from its wordlist, and prompt with the next flashcard
/=D - delete the current flashcard, removing it from its wordlist

For the following commands, you may omit the colon and <to-item-#>, in which case WHAT assumes a value of 1.

/=<wordlist-#>:<item-#>,<#-to-delete>D - delete the given item(s) from the wordlist
/<to-wordlist-#>:<to-item-#>=<from-wordlist-#>:<from-item-#>,<#-to-copy>C - copy the given item(s) to the specified place; the comma and <#-to-copy> may be omitted
/<to-wordlist-#>:<to-item-#>=C - copy the current flashcard to the specified place
/<to-wordlist-#>:<to-item-#>=<from-wordlist-#>:<from-item-#>,<#-to-move>M - move the given item(s) to the specified place; you may omit the comma and <#-to-move>
/<to-wordlist-#>:<to-item-#>=M - move the current flashcard to the specified place

In the above commands in which a number of items is specified, you may omit the comma and number, and WHAT assumes the value is 1. In the move and copy commands, if the to-wordlist does not exist, it is created. If the designation of the from-item is missing, the current flashcard is the from-item. If the to-item-# is 0, the destination is the end of the specified wordlist. If the to-item-# is higher than where the item can go (since there are not enough items), it is placed at the end. Item numbers start at 1. It is acceptable to move or copy an item within its wordlist, and it is even acceptable that the destination and source are the same, in which case nothing is done for the "move" command.

For a move or copy command, if you specify a destination item number for which there is already an item, overwriting is not done, but instead existing items are retained and the new items in the destination list are squeezed in.

For a move or copy command, it is possible that the same wordlist is specified for the source and destination, and it also possible that the destination item number is within the range of source items. WHAT accepts such commands and logically performs these as if it first copied the source items to a temporary holding place, when moving, it marks the source items for later deletion, and it then inserts the items being held at the specified destination position, and then the items marked for deletion are deleted. The copy command is performed similarly, except there is no deletion involved.

When an item that is the current flashcard is moving away from where is was due to a deletion, copy, or move, an attempt is made to either keep that card as the current flashcard or retract that as the current card, yet compute a potential next card, if this is meaningful. There are some situations where there is no possible next flashcard. If there is no current and no potential next card, flashcarding is turned off. First, we present what happens for a deletion or a move.

If the current flashcard is staying within its wordlist, it is retained as the current card. This may throw off the idea that sequential flashcarding will review every item in a wordlist. On the other hand, if the flashcard is being deleted or moved elsewhere, the current card is retracted. The potential next card is the first item following the group of items that is being deleted from the source wordlist.

A similar analysis is done when flashcarding is on and there is no current card, but there is a potential next card. That next card may need to be updated.

The above description was for a deletion or a movement of items among wordlists. In the case of copying an item that is a flashcard or potential next flashcard, the source item is retained as that card.

13.7  Labels

User-defined sets and wordlists may have associated labels. The commands to declare these objects allow for the specification of an optional label. When you supply a label, enclose it within quotes, and the label may not include a quote. WHAT imposes a maximum length of a label to the extent of what is stored. You may specify more characters than that, but WHAT will retain only a certain maximum number, namely 20.

The label for the slate is fixed at "Slate".

13.8  Source of Input for Queries

The usual (and default) source for words is the full list of words in WHAT's current lexicon. This can be changed for one query (for the short-term) or for subsequent queries (for the long-term) to be a particular wordlist, including the slate. This is especially useful if you want to do pattern matching kinds of queries against the current slate. The lexicon is the default source of words, and you can request that a particular wordlist can be used instead by your issuing a command of the form:

   /<opt-wordlist-#>I

Wordlist 0 is the slate. The command to change the source to the lexicon is:

   /-I
Beware that processing time for queries when the source is a large wordlist may be much longer than for when the source is the lexicon. If you have a large wordlist you want to use regularly for the basis of queries, you should contact us to have us turn this into a lexicon data file. At this time, the support software to create WHAT lexicons is not being distributed.

13.9  Source of Words for Word References

The usual (and default) source for word references in queries (denoted by square bracket specs) is the slate. This can be changed for one query (for the short-term) or for subsequent queries (for the long-term) to be a particular wordlist or the entire lexicon. When a square brackets spec is used in a query, one word at a time from the wordlist is treated. The slate is the default source of these words, and a particular wordlist can instead be used by your issuing a command of the form:

   /<opt-wordlist-#>[

Wordlist 0 is the slate. The command to change the source to the lexicon is:

   /-[
Beware that processing time for queries when the source for word references is the entire lexicon may be considerably longer than for when the source is a wordlist. This option should be used sparingly. For example, if you set the lexicon as the source for word references and use this query:
   *v,[]
it can take nearly 10 minutes to complete this. This is because asterisks other than trailing ones can take a long anyway, but this slowness is then compounded with the need to consider every word of the lexicon, one at a time. If you see a query is taking too long, you can stop it by pressing the Esc key.

13.10  Scoring of Words

You can request that WHAT scores the words it forms. These scores can be used as the basis of filtering words for the slate and for sorting the slate, and scores can be reported as part of slate presentations. You can elect whether blanks are to be scored as the letter matched or as zero. Scoring of blanks in pattern-match queries when there is a rack are scored according to the letter or set from the rack that is used; if it is a letter, that letter's score is used, but if it is a blank (or any set) it scores according to whether blanks are scoring as zero or what they represent.

Even when you have indicated that letters indicated by blanks are to be scored, they are scored as zero when there are not enough of the actual letters in the bag. For example, PIZZA scores 15 since the bag has only one Z. You can also control whether a 50-point bingo bonus be applied when a word has at least 7 letters. By default, zero-scoring of blanks is not enabled, but the 50-point bingo bonus is enabled.

Scoring can be done straight, without consideration of bonus squares on the board, but it can also be done with a board position as the basis for forming the score. When this is done, the additional score of connecting with perpendicular words is ignored. You can ask for scoring based on starting at a certain board position, or you can ask for a certain board position to be included somewhere in the word. In either case, you provide an orientation (horizontal or vertical) for the positioning of the play.

When you request start-square or include-square scoring, you may know of constraints for certain squares, according to already placed words on a board. Taking these into account is straightforward for start-square scoring, but not for include-square scoring. We have considered allowing for such a possibility and decided to not provide such a feature at this time. If and when full tile placement on a board is supported, that will provide the appropriate expressive power for asking such questions.

A future version of WHAT may support the placement of tiles onto a board and thus be able to provide a list of the highest-scoring plays based on a given rack. Meanwhile, WHAT supports some of what is needed to find highest-scoring plays.

These are the commands that control scoring:

/15S - score based on a 15 x 15 board size
/21S - score based on a 21 x 21 board size
/+B - score with a bingo bonus for words of at least 7 letters (the default)
/-B - score with no bingo bonus for words at least 7 letters long
/+Z - score zero for blanks (the + is optional)
/-Z - do not score zero for blanks (the default)
/@- - score with no bonuses other than perhaps a bingo bonus
/@*. - score for an opening play (starting at the center square)
/@*~ - score for an opening play (through the center square)
/@< board-square>. - start at this board square with given orientation
/@<board-square>~ - include covering this board square with given orientation
/@| - score based on word length for the 5 x 5 grid game (2,3,5,8,...)
/@W - score using word length times the sum of the letter scores, as is used in the Word-Building Game
Board squares are indicated by specifying the row and column of the square. For the 15 x 15 game, rows are numbered 1 to 15, and columns are designated A through O; these can be of either case. For a horizontal orientation indicate the row first. For example, for a 15 x 15 board, a word played starting on the center square is at board position H8 when it is played horizontally. If played vertically, it is at board position 8H.

When working with the 21 x 21 game, the same conventions are followed.

These are more commands related to scores:

/$<number> - yield only those words whose scores are at least this
/$<number>-<number> - yield only those words whose scores are in this range
/$<number><<number> - yield only those words whose scores are in this range
/$<rel-op><number> - yield only those words whose scores pertain
/$- - do not filter by scores
/<$ - sort presentation by decreasing scores
/>$ - sort presentation by increasing scores
/=$ - do not sort presentation by scores (the default)
$ - show scores in slate presentation
-$ - do not show scores in slate presentation (the default)
When words are being scored, only the highest score for a word is used as it is placed onto the slate. The slate can contain at most one copy of a word at any given time. If a word achieves the same score at more than one board position, the leftmost-uppermost position is the one noted.

13.11  Word Lengths

When the slate has double words, as produced for 2-word anagramming or two-word pattern matching, the word length for filtering and the word length shown (when requested) is the length of the first word.

When the slate has double words, as produced for 2-word anagramming or for 2-word pattern matching, the length of the pair of words is used for sorting and in slate presentation. In the presentation, the 2 words are separated by at least two spaces (and the spaces are shown with periods when output is other than one "word" per line). The length of each entry is dependent upon the length of the second word. For example, if the total number of letters specified for the 2-word query had been 10, the length of the entries may be between 12 and 18. It is 12 for when the second word is of length 2, and it is as much as 18 when the second word is of length 8.

These are commands related to word lengths:

/|<number> - yield only those words whose lengths are at least this
/|<number>-<number> - yield only those words whose lengths are in this range
/|<number><<number> - yield only those words whose lengths are in this range
/|<rel-op><number> - yield only those words whose lengths pertain
/|- - do not filter according to word lengths

When you specify that you want to yield words of length 0, WHAT interprets this to mean it will show words of the same length as the query. This is the default.

/<| - sort presentation by decreasing word lengths
/>| - sort presentation by increasing word lengths
/=| - do not sort presentation by word lengths (the default)
| - show word lengths in slate presentation
-| - do not show word lengths in slate presentation (the default)

13.12  Word Probabilities

Although we use the term "probability", these numbers are really the number of different ways a particular word can be formed from letters taken from a full bag of tiles, ignoring the blanks. So the probability of the rack AEINRST is the product of these counts: 9,12,9,6,6,4,6, which is 839808. You can therefore see the probability for a 7-letter word is no more than 7 digits. In general, for words usually played in a word game played on a 15 x 15 board, these probability numbers are about as long as the word length. Therefore they are represented in n+1 columns, where n is the word length.

To remove the burden on you to do calculations, you can specify a probability with a set of letters within curly braces. For example, you can specify probability of the rack AEINRST, which is 839808, as {AEINRST}, where the order of the letters is irrelevant. You can use such curly-brace-enclosed letter sets wherever a number is allowed in the following probability commands. Within these braces only repetition counts and letters are allowed; minus signs, plus signs, and exclamation points are not allowed. When you provide just one such brace-enclosed spec as a command, WHAT performs that command by reporting the numeric value of the probability.

As of WHAT Version 2.2, a user has the choice of which kind of number is associated with a word. Based on data collected by John O'Laughlin, each acceptable word is assigned a number according to how many times it showed in a large number of simulated games. For example, the most-played word in these games was found to be QI, and it is assigned a playability number of 1. Under user choice, WHAT can assign either a probability or a playability number to a word. Note that words with a higher probability tend to be the useful words a player would care about, but with playability the most desirable words are those with a lower numerical value.

The WHAT Initialization File can specify the name of a playability data file, and it can also indicate if playability is chosen option as WHAT starts. The file name of the playability file can be changed as part of the dialog to create a new WHAT Initialization File. Also, there is a menu-pick of File->Playability (Instead of Probability) which can be used to to toggle between the two choices of whether probability or playability is being used.

A playability file can be of either of two encodings. One is a text file, indicated by a file extension of anything other than WPB. Each line of the text file is a word; the most playable word starts the file, and subsequent lines have increasing playability numbers; thus a word's playablity number is the line number it is on in the text form of the playability file.

The alternate encoding of the playability data is in a binary file whose format is specific to WHAT. The file's extension is .WPB for WHAT playability. The same data is encoded in this binary file as the data encoded in the text form of the file. WHAT is distributed with a binary form of a playability file for the CSW2015 Lexicon;> - yield only those words whose probabilities or playability numbers are at least this /%<number>-<number> - yield only those words whose probabilities or playability numbers are in this range /%<number><<number> - yield only those words whose probabilities or playability numbers are in this range /%<rel-op><number> - yield only those words whose probabilities or playability numbers pertain /%- - do not filter by probability or playability /<% - sort presentation by decreasing probabilities or playability numbers />% - sort presentation by increasing probabilities or playability numbers /=% - do not sort presentation by probability or playability (the default) % - show word probabilities or playability numbers in slate presentation -% - do not show probabilities or playability numbers in slate presentation (the default)

13.13  Number of Words

When performing a query, WHAT can filter based on the number of words (or strings) in the answer. This is of no use for most queries, but it can be of use for those queries that use word references. In such filtering, the result words (or strings) are the full base words (or strings) from the wordlist (or lexicon) being used as the source of word references.

These are commands related to filtering based on word counts:

/#<number> - yield only those words from the source wordlist that lead to word counts of at least this
/#<number>-<number> - yield only those words from the source wordlist that lead to word counts in this range
/#<number><<number> - yield only those words from the source wordlist that lead to word counts in this range
/#<rel-op><number> - yield only those words from the source wordlist that lead to word counts which pertain
/#- - do not filter according to word counts
Although the phrase "word count" is being used in the above descriptions, it is really the result count for a query, since queries may result in strings other than words in the lexicon.

When you specify that a count of zero, this means you want to yield words that lead to no results. An example is you may want to find those 5-letter words that do not lead to 8-letter words when combined with 3 blanks.

13.14  Number of Anagrams

WHAT can report anagram counts, and these counts indicate the number of words that are formable from the letters involved. Thus if a word is presented, the minimum anagram count for it is 1, since the count includes that word itself.

These are commands related to anagram counts:

/&<number> - yield only those words whose anagram counts are at least this
/&<number>-<number> - yield only those words whose anagram counts are in this range
/&<number>-<number> - yield only those words whose anagram counts are in this range
/&<rel-op><number> - yield only those words whose anagram counts pertain
/&- - do not filter by anagram counts

When you specify that a count of zero, this means you want to yield words with no anagrams, which means you are asking for non-words only. The default is that you are filtering for anagram counts greater than 0.

/<& - sort presentation by decreasing number of anagrams in a set of letters
/>& - sort presentation by increasing number of anagrams in a set of letters
/=& - do not sort presentation by anagram counts (the default)
& - show anagram counts in slate presentation
-& - do not show anagram counts in slate presentation (the default)

13.15  Anagrams

Slate presentation can include a word's anagrams within parentheses following the word. This feature makes little sense when the kind of query is "Anagrams", unless the items on the slate are other than words. This feature is provided especially for when the query kind is "Patterns". For example, perhaps you want to see the 7-letter words that begin with "OUT" and also be told of any anagrams for them. If you are using this option to prepare a study list, consider setting the format for slate presentation to be packed rows that are not columnated, since some words may have a lengthy presentation.

See the section "Categories of Slate Contents" some details relating to the presentation of anagrams.

The commands that affect this are:

) - show anagrams within parentheses along with secondary lexicon indicators in slate presentation
-) - do not show anagrams in slate presentation (the default)

13.16  Hooks

A hook letter for a word is a letter that may be prefixed or suffixed to the word to form another word. A front hook is a letter that may be prefixed, and a back hook is a letter that may be suffixed. WHAT deals with hooks for both query filtering and in slate presentation. These are the commands related to query filtering and presentation of hooks:

/<<rel-op><set-spec>) - yield only those words that have front hooks that are related to the letters in the set
/<- - do not filter by front hooks
< - show front hooks in slate presentation
-< - do not show front hooks in slate presentation (the default)
/><rel-op><set-spec> - yield only those words that have back hooks that are related to the letters in the set
/>- - do not filter by back hooks
> - show back hooks in slate presentation
-> - do not show back hooks in slate presentation (the default)

When front or back back are shown in slate presentation, there is a user-specified front hooks separator included in the output which separates the front hook letters from the word. Similarly, there is a user-specified back hooks separator included in the output which separates the word from the back hook letters. In order to specify these separators, menu pick View->Hook Presentation Separators.... Each of the separators can be a null string (i.e., nothing) or a sequewnce of characters to up to length eight.

13.17  Query Filtering

When WHAT processes a query, it uses matching rules according to what letter designations are in the query to come up with acceptable words. Of course, the rules are different for anagramming and pattern matching. Once a word does match the query pattern, there is then the possibility that is may be filtered out according to other criteria:

We call the output of this filtering what is yielded by a query. The previous sections have included indications of how to control what is yielded according to specified constraints for such query filtering.

Just to clarify, the slate is accumulated with words or strings as a result of the matching of the query and the query filtering. What slate contents you can then elect to see is a separate matter. Also, the ordering of the words when the slate is presented is another matter.

13.17.1  Filtering for Word Length

This topic is obvious for most of the kinds of queries, but for two-word queries, the length is that of the first of the two words.

If you have specified to filter based on word length, and if the minimum length specified is higher than length implied by the length of the query, you are told that no answer is possible. For example, if you make the query

   A.O /|=4
you are asking for words of length 3 which start with an A and end with an O, and furthermore you want to see only words of length 4, according to the filtering spec. WHAT will indicate:
The query seeks 3-letter answers, but filtering specifies 4 letters.

13.17.2  Filtering for Word Count

Like filtering for the blank (describing in the next section), this feature of WHAT is quite specialized, and most WHAT users will have no need for this.

It is used especially to seek certain kinds of words in conjunction with queries that include word references. For example, if you have a certain list of 6-letter words or strings and you want to find out which of these when combined with 2 blanks yield exactly one word, you would employ this kind of filtering. Notice that the words produced in the answer are the very ones that were being used as the source of the query. The entire word of the source of the query is in the answer, even if a subword of that word is involved in the specification of the query.

If this form of filtering is requested in a query which has no word references, it is ignored. This behavior may be changed in future releases of WHAT.

13.17.3  Filtering for the Blank

Like filtering for word count (described in the previous section), this feature of WHAT is quite specialized, and most WHAT users will have no need for this.

It is used especially to work with anamonics. Another use is when also when the query is a steal or rearrangement steal. Using this feature is useful only when a query includes word references.

You provide a "base set" against which what the blank can be for each word is compared. This base set should have zero or one instances of each letter, since letter counts have no purpose in this context. You specify the base set explicitly, possibly with a leading exclamation point to mean "not". Any repeated letter in your specification is ignored. For the filtering, the set of letters the blank can be for the word is compared against the base set you specify, except that if you include a minus sign within the parentheses of the set specification, this is an indication that the vowels (A,E,I,O,U) are to be ignored in the comparisons if they are not present within the specified set. This option is provided in case you are working with anamonics and want to find various sets of letters that take the same consonant anahooks. This is indeed subtle.

When using blank filtering in conjunction with a steal or rearrangement steal query, the filtering is done only when the steal can be made with only one blank. Otherwise, the filtering request is ignored.

Various relationships are supported:

An empty base set is permissible in this context.

These are the commands related to query filtering of what the blank can be:

/:<rel-op><set-spec> - yield only those words for which what the blank can be are related to the letters in the set
/:- - do not filter by what the blank can be

If you include a leading minus sign in the set spec, it is interpreted to mean that vowels  A,  E,  I,  O, and  U are not included in the comparisons. This feature is supported for your working with anamonics, where vowels are sometimes ignored.

13.17.4  Filtering for Hooks

This feature of WHAT is quite specialized, and most WHAT users will have no need for this.

Two of the possibilities for query filtering are related to the front hooks and back hooks. For either of these, provide a set against which the hook letters for each word are compared. This "base set" should have zero or one instances of each letter, since letter counts have no purpose in this context. You specify the base set explicitly, possibly with a leading exclamation point to mean "not". Any repeated letter in your specification is ignored. For the filtering, the set of hook letters for the word is compared against the base set you specify. Various relationships are supported:

An empty base set is permissible in this context.

These are the commands related to query filtering of what the hooks can be:

/<<rel-op><set-spec>) - yield only those words that have front hooks that are related to the letters in the set
/><rel-op><set-spec> - yield only those words that have back hooks that are related to the letters in the set
/<- - do not filter by front hooks
/>- - do not filter by back hooks

13.17.5  Filtering for Definition Contents

/"<optional-excl><search-string>" - filter according to definition contents
/"- - do not filter according to definition contents

You can filter based on a word's definition text when WHAT is using definitions. Realize that words which are too long have no definitions, so such words will not be matched when seeking definitions with a given string. You can also filter based on a string's not in a definition. All words with no definitions will be accepted in this filtering. You indicate filtering based on a string's not being in a definition by starting the string within quotes with an exclamation point. Other than that possible leading character, the remainder of the string within quotes is the basis of the search, but it assumed to be surrounded by individual spaces. To inhibit the assumed space before of after the string, include a vertical bar there.

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

Here is an example of a fitering subcommand for finding all words which have the word "dog" in their definitions:

   /"dog"
For this filtering subcommand, the word "dog" must be enclosed in spaces. If you instead asked to filter based on the string "dog" anywhere within a definition, with this subcommand:
   /"|dog|"
many words would match, such as "GRAYFISH" since its definition includes the word "dogfish".

This is an example of finding all the OWL3 words which include the string "zebra" in their definition:

   * /"zebra"
The output from this query is:
   ZEBRASS   ZEBRASSES ZEBRINE   ZEBRINES  ZEBROID
Seeking strings in definitions is done case-insensitively.

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.

1.13.18  WHAT Command Repertoire

The complete list of commands and command fragments is listed in the companion reference document, WHAT Commands.

14.  Slate Presentation

The outputting of words and strings to the slate is the first half of the work done by WHAT as it performs queries. It is a separate second step which you control to look at the contents of the slate.

14.1  Outputting Strings

WHAT allows for words being placed onto the slate not to be acceptable words, although this is not the usual style of WHAT use. You can use command /QS to indicate the result of a query may be arbitrary strings. In such a case, if there is a blank in the query it may represent each of the 26 letters. Using blanks in a string query in this manner is discouraged. At most 4 blanks and sets are permitted to be specified in a query that results in strings.

This feature is being provided without appreciating many of its implications. One use we envision is to output a canonical ordering of a word instead of a word, and therefore anagram sets will be represented by one representative.

We also envision the kind of use it could have is to collect word fragments, such as what triplets can be placed in front of a 5-letter word starting with a Q to make an 8-letter word.

14.2  Characters Matched by a Blank

When a query includes exactly one blank (or more precisely, when all items in the answer have one letter matched to a blank), the query-based set denoted by

   (=)
becomes those letters that the blank can be, and you can ask to see that list by typing an equal sign as part of a command. When there is more than one blank in a query, the result of the presentation of the slate using the equal sign is not a set, but it is collection of groups of letters separated by commas, where each group are those letters the set of blanks can be. The blank-representing set, denoted by (=), is still a set of letters, and these are all the letters that any of the blanks represent, but this set may be of little utility when two blanks are involved.

When the slate is presented, one possible sorting can be based on what letters a single blank in a query can represent. This is specified in the same manner as other specifications for sorting:

/<: - sort presentation by decreasing alphabetical order for what the blank can be
/>: - sort presentation by increasing alphabetical order for what the blank can be
/=: - do not sort presentation by what the blank can be (the default)
This feature is limited to queries with one blank. Future versions of WHAT may allow for more than one blank.

These are related commands:

: - show what the blank is, presenting one such letter per line in slate presentation; the presentation is ordered by the alphabetical order of what the blank can be
-: - do not show what the blank is in slate presentation (the default)

As with other criteria for sorting, you may elect to show an aspect of a word. If you use the command to show what the blank is, output format is one such letter per line, and that line may have one or more words that are in the output for when the blank is that letter. An example can serve to explain this more clearly. For the query

   rptyae?:
the presented output is:
B: TYPEBAR
H: THERAPY
L: PEARTLY PEYTRAL PTERYLA
R: PARTYER
X: APTERYX

When slate output is organized based on what characters a blank matches, an additional criterion can be employed to order the slate presentation, and that is the number of anagrams for a given set of letters. When output is based on the blank, then one line contains an anagram set. You can request that WHAT sorts it output according to the number of words in such a set:

/<& - sort presentation by decreasing number of anagrams in a set of letters
/>& - sort presentation by increasing number of anagrams in a set of letters
/=& - do not sort presentation by anagram counts (the default)

The above commands have an effect only when the presentation of the slate is based upon what characters a blank matches. However, if long-term specification is done, it is remembered, even during durations when there is no effect.

These are related commands:

& - show anagram counts in slate presentation
-& - do not show anagram counts in slate presentation (the default)

WHAT does not have commands to filter words going to the slate based on the number of anagrams.

For the query

   rptyae? : & /<&
the presented output is:
L: (3) PEARTLY PEYTRAL PTERYLA
B: (1) TYPEBAR
H: (1) THERAPY
R: (1) PARTYER
X: (1) APTERYX

14.3  Definitions

WHAT can support the presentation of word definitions if it you supply it with a definitions file. The program does not come with such a file, but if you can obtain such a file and provide it to WHAT, it can then include definitions in its output. The WHAT web site includes information that is pertinent.

A word definitions file may optionally start with one identification line which begins with a tab; it is followed by a short description of the file, such as the file name and the date in parentheses.

All other lines of a word definitions file begins with one or more words in lowercase separated by single spaces and terminated with one tab character. All inflected forms of the base word are included in this word list. Following the tab is the base word and its definition. The base word is all uppercase. That is followed by a part-of-speech indicator and also inflections of the base word if any. The remainder of the line is the brief definition. The file is alphabetically ordered. Here is an example line:

abhor abhors abhorring abhorred	ABHOR v -HORRED, -HORRING, -HORS to loathe

A presented definition begins with the uppercase base word. WHAT assumes a definition line does not exceed 255 characters.

The commands that control inclusion of definitions in slate presentation are:

" - in slate presentation, present words one per line, and include one definition of the word; when a word has more than one definition, a plus sign is used as as a separator instead of the usual minus sign; when the presentation layout is not set to one word per line, all definitions of the word are shown on subsequent lines in the presentation
-" - do not show word definitions in slate presentation (the default)

There is also a mechanism via the WHAT GUI to request a definition of a word on the screen by double-clicking that word. The word may be in the workspace or in the portion of the WHAT window where definitions are shown. When a word's definition is shown in this Definitions area, all of its definitions are shown. When a definition is shown in the workspace, its first definition (in the definitions file) is shown and other definitions are also shown unless the layout is set to one word per line. The separator used within definitions presented in the Definitions area is either a plus sign or minus sign according to whether the word has or does not have more than one definition.

Here is an example:

WHAT?: grit"

GIRT + GIRD v GIRDED or GIRT, GIRDING, GIRDS to surround
     + GIRT v -ED, -ING, -S to gird
GRIT - GRIT v GRITTED, GRITTING, GRITS to press the teeth together
TRIG + TRIG adj TRIGGER, TRIGGEST neat
     + TRIG v TRIGGED, TRIGGING, TRIGS to make trig

You can request that WHAT shows all the definitions which include a given search string. This is not exactly the same as using the facility to filter by definition contents. With filtering, the basis of the output is words which pass the filtering criterion. With this /SD command entire definitions are shown. This is the command:

   /SD<search-string> - show all definitions which include the given search string

You can make use of this command only when WHAT is using definitions. Realize that words which are too long have no definitions, so such words will not be matched when seeking definitions with a given string. You can also filter based on a string's not in a definition. All words with no definitions will be accepted in this filtering. The search string within quotes is the basis of the search, but it assumed to be surrounded by individual spaces. To inhibit the assumed space before of after the string, include a vertical bar there.

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

Here is an example of a Show Defiinitions command for showing all definitions which include the word "dog":

   /SD"dog"
For this command, the word "dog" must be enclosed in spaces. If you instead asked to show definitions based on the string "dog" anywhere within a definition, with this command:
   /SD"|dog|"
many definitions would match, such as the definition of "GRAYFISH" since it includes the word "dogfish".

14.4  Presentation Format

Slate presentation is done in the workspace of WHAT. Workspace size is controlled by the size of the WHAT window. You can control the width and height of the WHAT window. You may also control the size of the font employed in the workspace. When you resize the window or change the font size, the size of the workspace being shown in the lower right corner of the WHAT window (in the status bar) is updated.

You can also see the size of the WHAT window in pixels by holding down the left mouse button when the cursor is anywhere within the status bar.

The presentation width is first set automatically to match the size of the workspace as WHAT starts up. If you subsequently resize the WHAT window or change the workspace font, the presentation width may automatically be updated; otherwise, it is not changed.

At present, there are no commands to control width, height, and font. Such commands may be helpful in an environment when WHAT is not being run with its complete GUI.

When WHAT presents a word, it is shown in its entirety without breaking it across lines. Whether to relax this restriction someday for breaking within anagrams of a word is TBD.

These are the commands involving the layout of presentations:

/O1 - (letter O, digit 1) slate presentation is one word per line
/OR<number>S - words in packed rows, with spacing = <number>
/OR,<number>S - words in packed rows, use comma, with spacing = <number>
/ORC<number>S - words in columnated rows, with spacing = <number>
/ORC<number>W - words in columnated rows, with fixed width = <number>
/ORC<number>X - words in columnated rows, with expandable width = <number>
/OC<number>S - words in columns, with spacing = <number>
/OC<number>W - words in columns, with fixed width = <number>
/OC<number>X - words in columns, with expandable width = <number>
All the above numbers must be in the range 1 to 80.

Some of the above wording is sparse and some explanation is in order. When the second option is chosen, words are presented across rows, with a given number of spaces to separate them. When the words are of varying lengths, they will not line up in columns.

In all options other than the first two, words are presented in columns, and there are three ways to determine the spacing:

suffix S - column width is n more than the widest word, where n is the given spacing,
suffix W - column width is the given width (n); for longer words, they are presented in subsequent sections where the widths are multiples of n,
suffix X - column width is the higher of the given width and 1 more than the widest word.
The default layout that WHAT employs is: words in columns with an expandable width of 9.

No matter what the layout style is, when definitions are included in the slate presentation, the style is forced to be one word per line.

Here are more commands involving the layout of presentations:

/OC<number>C - set the number of columns for presentations, with allowable values: 1 through 30
/OW<number>C - set the width of presentations in number of characters, with allowable values: 8 through 255
/OWA - set the width in characters for presentations to match the current workspace width (this is the default)
At a given time, only one of the above situations is in effect. The presentation width is either in terms of columns or characters.

/OR<number>C - set the number of rows per page (0 for no paging), with allowable values: 0 or 8 through 255; this affects only outputting in columns, and a page break is indicated by a line of minus signs

Other aspects of output that you cannot currently modify may be under your control in the future, and these are the specifications of fonts of output for presented data other than words.

14.5  Presentation Details

First of all, recall that the slate is usually ordered alphabetically, but its presentation order may be affected by sorting based on other criteria. For example, word score can be the basis for sorting. Whether scores are presented as part of the output is an independent question from whether sorting is done based on scores. As indicated in an earlier section ("Scoring of Words"), a single $ is used to indicate you want to see scores. You can independently indicate presentation order should be based on scores via />$ or /<$ subcommands. Another aspect related to scoring is when a query is performed you can specify a filtering of the words that are sent to the slate. Namely, you can control which words are placed onto the slate based on their scores.

When scores are being shown, if the score is based upon a board position that position is shown unless the word presentation is for hidden words. In this way, you can get the minimal information about what words score without getting too much info.

You have considerable control over what about the slate WHAT shows and how much additional information it shows. The default presentation of the slate is that WHAT shows all words, alphabetized and presented in columns, and it shows these words without additional information, other than coloring some letters with a distinctive color, such as lime green (when the slate contains lowercase letters and when those are being shown in this manner). Whether these lowercase letters are placed onto the slate as the result of a query is an option under your control. It is separate option under your control whether such letters are then shown as colored uppercase letters. If you have chosen this, colored letters are shown only when the query result is not words or strings in canonical order, or when there are no lowercase letters in the canonical order.

If the amount of output is extensive, you may want to stop it before the presentation is complete by pressing the Esc key. You will be told that the output was cut short.

Here are the aspects of slate presentation that you may control:

\ - indicate slate presentation consists of nothing
~ - tilde indicates WHAT should present no words, but it will make one announcement as to whether the slate has any words; equivalent to 0~
<number>~ - indicates you want to see no words presented, but you will see one announcement as to whether the slate has this given number of words
# - indicate WHAT's presentation of the slate is limited to indicating how many items are on the slate
#= or =# - indicate WHAT's presentation of the slate is limited to indicating how many different letters or letter pairs the one or two blanks can be in the most recent query (ignoring 5 x 5 grid game and two-word anagramming queries)
= - indicate WHAT's presentation of the slate is limited to indicating those letters exactly one or two blanks represent in the most recent query (ignoring 5 x 5 grid game and two-word anagramming queries)
' - indicate WHAT should present individual words in the order that each one is on the slate; this is typically in normal word order, but this can vary according to query result settings
; - indicate words are to be presented in canonical order
] - indicate words are to be presented hidden (only by "[]")
$ - indicate words are to be presented with scores
-$ - indicate words are to be presented without scores
| - indicate words are to be presented with lengths
-| - indicate words are to be presented without lengths
% - indicate words are to be presented with probabilities or playability numbers
-% - indicate words are to be presented without probabilities/playability numbers
& - indicate words are to be presented with anagram counts
-& - indicate words are to be presented without anagram counts
: - indicate words are to be presented grouped by what blanks are
-: - indicate words are not to be presented grouped by what blanks are
) - indicate words along with secondary lexicon indicators are to be presented with anagrams in parentheses
-) - indicate words are to be presented without anagrams
< - indicate words are to be presented with front hooks
-< - indicate words are to be presented without front hooks
> - indicate words are to be presented with back hooks
-> - indicate words are to be presented without back hooks
` - indicate words are presented with unhook indications
-` - indicate words are to be presented without unhook indications
" - indicate words are to be presented with definitions
-" - indicate words are to be presented without definitions
Hooks are individual letters that can be prefixed or suffixed to words that then leads to the formation of another word. These are presented as a list of lowercase letters at either end of the presented word, which is presented in uppercase.

Unhooks are individual leading or final letters (or both) of a word that may be dropped to form other words. An unhookable letter is shown with a prefix or suffix of a minus sign to indicate the first or last letter can individually be dropped to form another word.

Here are some real example presentations with hooks and unhooks:

  -WHAT-s
  -ASPIRING-
   TOXINE-s
  -BREADsy
   ACARId
   SCARF-s

Along with words (and their hooks and unhooks), you can request that the slate will be presented with various additional aspects of the words:

Words on the slate may be presented as is or in canonical order. Also realize that the slate may have been created with canonically-ordered words.

14.6  Sorting Orders

WHAT supports sorting according to these 7 criteria (or keys):

The anagram count criterion is applicable only when words are presented based on what the blank can be.

[This deserves review - TBD.]

For each of these, the order can be increasing or decreasing. Think of there being 7 slots for potential sorting. The primary spot, or the first one is where the primary key for sorting is held, etc. One of these 7 criteria may either appear in this list at one spot, else it is missing from the list, and thus the list does not contain the full 7 members. When you specify a sort, it goes to the primary position of the list, perhaps being pulled out from another list position, else coming out of lack of use. There are commands to not sort based on a criterion, and uttering such a command, removes that criterion from the list.

The list is set up in a long-term manner, and it can be modified for an individual command. To distinguish between these cases, we follow a command with an exclamation point when it is meant to have a long-term effect. It could be on a query line, in which case it affects that current query, but it also sets the long-term situation.

14.7  Case of Letters in Query Output

When words are placed onto the slate as the result of WHAT's performing a query, both lowercase and uppercase letters may be used. Whether lowercase letters is an option under your control; this option is on by default. When the option is on, letters in the query result which were matched by a blank, a set, or some wildcard character are created in lowercase. When the option is off, all letters in the query result are uppercase. A word is on the slate only once, but there may be more than one attempt to place the same word on the slate. The same rule is used for placing words onto the slate as is used when performing wordlist unions. That is, a lowercase letter is used in the slate word when that very word being placed onto the slate has that letter as lowercase. This is most likely something you will see when you choose to augment slate contents with the results of a query.

Slate presentation is done using uppercase letters, except for hook letters, definitions, etc., but words are presented in uppercase. Lowercase letters are employed on the slate to indicate that letter is there since it is based on a blank, set, or wildcard character. Under your control, such lowercase letters are usually (by default) presented as uppercase with a lime green color when the query result is not canonically ordered words or strings, or when there are no lowercase letters in the canonical order. If you turn off this option, lowercase letters are shown as non-colored lowercase letters. This option is helpful when preparing output to be printed, since colors do not show in printed output, but the case of letters does. You can see these lowercase letters in a few of places, such as:

WHAT may fool you to the extent that if the slate has all lowercase letters, the lime green color is not used in the presentation. So, your seeing no lime green is not sufficient to conclude the slate has only uppercase letters.

Especially for the further uses of files, you may want to control the case of letters in exported wordlists. There are two subcommands which affect all letters on the slate:

/LS - make all letters on the slate lowercase
/US - make all letters on the slate uppercase
These above subcommands are carried out before slate presetation takes place in a command with a query.

When the slate contents are words, another way you can convert the slate into uppercase is to issue the command

   []
which is a pattern-match query for each word on the slate.

These are the subcommands to control whether lowercase letters are placed onto the slate as part of query results and whether such lowercase letters are shown as colored uppercase letters or as lowercase letters:

/+LB - show matched blanks with lowercase letters when outputting to the slate (this is the default)
/-LB - do not specially show matched blanks when outputting to the slate and in flashcard presentation; use uppercase letters only
/+LC - lowercase letters on the slate are presented as colored uppercase letters (this is the default)
/-LC - lowercase letters on the slate are presented as is, not as colored uppercase letters; lowercase letters in flashcards are presented as is, not as colored uppercase letters; if you choose this option, you cannot also make sense of hook letters in slate presentation, which are also shown in lowercase
When a query includes only blanks, sets, and wildcards, the /-LB subcommand is assumed, and you can override this by including a /+LB subcommand in the command.

You can count the lowercase letters on the slate with either of these commands:

/#L - count the lowercase letters on the slate, and issue a report which includes the total and the distribution
/#B - count the letters denoting blanks on the slate, and issue a report which includes the total and the distribution
These commands do the same work, but the words used in the issued report are indicative of which command you typed.

14.8  Probing the Slate and Other Wordlists

Here are some commands that may not be combined with other commands. These are for immediate performance - they have no long-term versions. Such probes of the slate are likely to be used when the slate contents has not been shown, and you want some hints about the words that are there:

<word>/? - indicate whether the given word is on the slate, if it is, do not indicate where it is;
<word>/0? - indicate whether the given word is on the slate, if it is, also report on where it is, with current sorting taken into account.
<word>/-"<lexicon-name>"? - indicate whether the given word is in the specified lexicon.
The zero in the above command represents wordlist 0, which is the slate. The general form of that word-probe command is:

   <word>/<opt-wordlist-#>?

Since these commands result in stating the item number where the word is, when you provide a wordlist number, you may be told more info than you want to know if you are testing yourself. If you want to hide where in a list an item is, you can shuffle the list in place or copy the list to another list and then shuffle that copied list. Another possibility is to make a wordlist the source of words, and then use the <word>/-? to make the probe. Once a particular wordlist is the source of words, you can type the word followed by a comma, and either it will be shown as output (when it is in that wordlist), or you will see the red "(nothing)" answer.

Another form of word probe command is:

   <word>/-?

that asks whether the given word is in the primary lexicon and also whether it is in the secondary lexicon, if there is one.

In these probing commands, only the letters of each item in a wordlist are considered, whereas in the following commands to show individual characters every character of an item is significant:

<letter-#>/ - show the nth letter of all items within the first 50; if there are more than 50, an ellipsis is suffixed in the output
<letter-#>/0 - show the nth letter of all items within the first 500; the output may be one letter per item or when the output is more compact, counts precede each letter
<letter-#>/<item-#> - show the mth letter of the nth item
/<item-#> - present the nth item

Item numbers are interpreted according to the order of slate presentation. What is reported for a complete item (for a /<item-#> command) is according to the slate presentation option, except when it is to report nothing, the word is reported in slate order along with any other data that you may select. When reporting individual letters, WHAT may indicate answers, such as:

  Letter 1 of word 2 is: R
  Letter 1 of each word is: A,R,T

When letters are being reported, if the slate has more than 25 words and thus more than 25 letters are being reported, the commas are dropped. If the slate has more than 50 words only the first 50 contribute to the output.

14.9  Selecting Lexicons

  • There are commands within WHAT's repertoire which set one of the three lexicons: primary, secondary, or challenges. Although these lexicons can be selected on the dialog accessed via the Lexicon tab at the upper right of the WHAT screen, setting via commands may be useful to users, such as when lexicon changing may be desired within command files. The commands are: The given lexicon name is the short form of the chosen lexicon.
  • 15.  Multiple Commands on One Line

    The WHAT command language allows for your providing multiple commands on one command line. There are some commands which WHAT carries out when is sees it on the command line, and then it ignores any further commands on the line. These are the commands that are acted upon in this way:

    [TBD] - Look around for other commands that should be in this list...

    /15S - score based on a 15 x 15 board size
    /21S - score based on a 21 x 21 board size
    /<item-#> - show the nth item on the slate (command must stand alone)
    /<number>H - show command history beginning with the command designated by the given number and show as many commands going forward as almost fills the output area (if that many exist).
    /<wordlist-#>L<opt-label> - associate the given label with the wordlist; if no label is provided, eliminate any existing label.
    /<opt-set-#>U<opt-label>=<opt-set> - declare a user-defined set
    /C - bring up the Challenge Dialog, perhaps starting with any comma-separated words on the current line
    /END - one of the commands to stop the WHAT session (also /EXIT and /QUIT); this also causes WHAT to stop executing commands from a command file (but not exit)
    /EXIT - one of the commands to stop the WHAT session (also /END and /QUIT); this causes WHAT to exit even when it is performed from within a command file
    /H - show recent query history so that it almost fills the workspace; command numbers are included
    /-I - change the input for queries to be the lexicon
    /<item-#> - show the nth item on the slate (command must stand alone)
    /<wordlist-#>I - change the input for queries to be this wordlist
    /L - see all the wordlists in a report with one wordlist per line, where these are shown: wordlist number, label, number of words
    /M"<26 letters>" - define WHAT's letter mapping
    /M? - show WHAT's letter mapping
    /QUIT - one of the commands to stop the WHAT session (also /END and /EXIT); this causes WHAT to exit even when it is performed from within a command file
    <letter-#>/ - command to show the nth letter of all items
    <letter-#>/<item-#> - command to show the mth letter of the nth item
    {<letters>} - show the probability of this set of letters
    When a command line includes various commands and perhaps a query, certain of these commands are performed in relation to the query and each other in a particular order:

    16.  A Review of Query Processing

    WHAT may clear the old slate and place the results of the query output onto a clean slate, else it can merge the query's output onto the current slate.

    Before a query takes place, the slate may be restored from a given wordlist. This option is of use only when the contents of the slate is involved with the query, and there are two aspects for this to be the case:

    Before a query takes place, the slate may be forced to all lowercase or all uppercase.

    When there is a query based on words of the slate, a copy of that slate is first made for the purposes of having the input words to the query be a wordlist that is not affected by the possible simultaneous output to the slate.

    WHAT has one kind of query it can be doing, such as:

    The default is anagram (when WHAT first starts up), but the user can change this for all further queries and temporarily for the current query.

    There is one subkind of query that applies to both anagram and pattern matching kinds, and it is the circulation of the blank.

    There are two different sources of a query:

    The second kind of query source is specified by including one or more square bracket word references within the query. Such word references are specified beginning and ending with square brackets, possibly enclosing a subword spec.

    For anagramming and pattern matching kinds of queries, there is an option whether each of the words is placed onto the slate in word order or whether it goes there in a user-specified canonical order. When outputting in canonical order, string output to the slate is assumed. The output for two-word anagramming is necessarily strings and not just words for the slate. So, there is this one aspect of the slate whether it contains words or strings.

    When a query is performed, the slate contents may be replaced or augmented. In either of these cases, there can be several criteria of filtering that take place, and these are they:

    One more step of filtering is according to whether the result is a word.

    Filtering is a separate issue from how the slate is presented. Filtering just controls that words (or strings) otherwise matched by the query get placed onto the slate.

    When a query is made, the slate may then get copied to one or more wordlists.

    17.  A Review of Slate Presentation

    WHAT may or may not present one line for each letter one blank matches (when there is exactly one blank in the query).

    When WHAT presents words, each may be followed by any of these data:

    Each of these fields is presented with a suffix letter to indicate its purpose:

  • p for points of word score
  • s for size of word
  • w for ways of getting that word (its probability)
  • y for the pla
  • yability number
  • a for anagram count
  • For the word presentation there are these possibilities:

    WHAT has these number of words possibilities:

    WHAT has various ordering possibilities, there is a primary order and then other secondary orderings. These are the various presentation orderings:

    There are 3 output formats that apply to the word presentations in the absence of the inclusion of definitions; you may set these for the long-term or just for this query:

    When definitions are being shown, each word is placed on one line, and the definition follows the word.

    18.  File Reading and Writing

    WHAT is capable of importing (reading) and exporting (writing) files containing:

    All but the last one of these commands begin with /F and the next letter is:

    Further parts of these commands can be:

    <number>H - for one command (output only)
    <from-#>-<to-#>H - for a range of commands in the history (output only)
    <from-#><<to-#>H - for a range of commands in the history (output only)
    15B - for 15 x 15 Game Boards
    21B - for 21 x 21 Game Boards
    15G - for 15 x 15 Game Recorded Games
    21G - for 21 x 21 Game Recorded Games
    12B - for Word-Building Game grids
    H - for all commands in the command history When this is used with reading, the commands read are added to the history, but are not performed
    S - for the slate
    W - for the wordlist whose number is the lowest unused number when reading or the highest used number when writing
    <number>W - for a particular wordlist; when the slate is written to a file, it is ordered according to current sorting, but it is not written as slate presentation; if you want to write out a slate presentation, output the workspace.
    K - for the workspace (output only)
    D - for the Definitions Window (output only)

    When a wordlist is exported, for other than the slate, if it has a label that label is written to the first line of the created file following three forward slashes. Similarly, when a wordlist is imported other than to the slate, if the file has a first line beginning with three forward slashes, the remainder of that line is used to set the wordlist's label. Labels retained in the program are limited to 20 characters. Any excess characters in the label from the file are ignored. When using the WHAT dialog to set up the importing of a wordlist, you can specify a different label for the wordlist. A comparable control when exporting is not supported.

    When a wordlist is imported, every line is checked to see if it contains a word in the primary lexicon. If so, WHAT categorizes that wordlist as having words; otherwise, that wordlist is considered to have strings.

    When a wordlist is imported, the order is preserved; however, if you look at it using default presentation, it will be presented in alphabetical order. Default presentation includes such a sort, but you can remove the one default sorting. If the wordlist is not excessively large, you can look at it via the Wordlists Tab at the upper right of the WHAT window. Duplicates are not removed during wordlist importation. Duplicates are removed as a result of making a query; so, if you have a wordlist of items that include non-words, and you want to remove duplicates, move it to the slate, and issue this command:

       []/QS\
    The result is devoid of duplicates and also sorted alphabetically.

    The other form of file-reading command is:

    /X - execute (i.e. perform) each read line as a command and record them in the history; /X commands may appear in command files, but only to a depth of 10; certain interactive commands may not be used within command files, such as /C and /G

    All of these file commands each end with the file name enclosed in quotation marks.

    When importing a wordlist, leading and trailing spaces and tabs are removed.

    When query characters are included on a command line along with the /X command, those characters are remembered, such that if an early line in the command file begins with an exclamation point, it refers to those characters.

    When 5 x 5 game grids are written, each line has 25 or 26 (when there is a digram cube) letters followed by "/G". When these grids are read, a single letter following a slash is ignored, and thus such lines could have the suffix of "/G", but they could also have /B on the line.

    When working with 15 x 15 or 21 x 21 games, there are ways to create and read board configuarions and recorded games (in .gcg files), but there are not WHAT commands to support these activities. Importing boards and recorded games can be invoked by menu-picks in addition to clicking on buttons on the Board Dialog. Both importing and exporting 5 x 5 Game grids can be done from menu-picks and from the game dialog.

    19.  Command Files

    As mentioned in the previous section, the /X command is used to execute a command file. The one argument of this kind of command is a file name. WHAT can help you construct such a command via the menu pick File→Execute Commands from File..., and then you press Enter to perform the command.

    WHAT interprets each line of a command file as an individual command line. Nearly all commands may be used within command files. This includes /X commands, but WHAT limits their use to a depth of 10. As a command file is used, the commands are shown in the workspace. One exception is that when an /X command with no error is seen in a command file, that command is not shown. One group of commands may not be used within command files, and these are interactive commands, such as /B, /C, /G, and /WB.

    When an /END command is performed from within a command file, it is interpreted to end the use of that file, rather than exiting WHAT. A /QUIT or /EXIT command performed within a command file does cause WHAT to exit.

    There is one command which may be used only within command files, and that is the /NR command to get the next flashcard and rewind the command file when successful. In the absence of success for any of various reasons, the command does nothing, and control continues to the command on the next line, with no indication of what the problem is. The intended purpose of this command is to use sequential flashcarding to iterate over a list of items in a wordlist. Here is one example of such a use.

    Suppose you have a list of strings in a file and you want to produce a printed document which you can use to quiz yourself. The document will list each of the strings and then mention each of the letters which may be added to the string which will yield at least one word when anagrammed. Let us use an input file named: C:\msw\input.txt and plan to make an output file named C:\msw\output.txt. The contents of the input file is:

    ABC
    DEF
    XYZ
    GHI

    Prepare a command file with these lines:

    !/P/QS'
    !?=
    /NR
    One way to do this is using a text editing program outside of WHAT, such as by Notepad, EMACS, or MS Word. You can also use WHAT to help you prepare such a command file. To do this, clear the command history, type the commands, and then export the command history to your command file. Let's say the name of the command file is: C:\msw\anahooks.cmd

    The use of the leading exclamation point in the above commands is to indicate you are reusing the most recent query and rack specification, and in this case, it is the query made from the most recently selected flashcard, either from the initial /3FC command (mentioned below) or from the /NR command at the end of the command file.

    Now to do the intended job, begin by importing the input file with a command, such as:

       /FR3W"C:\msw\input.txt"
    which puts the lines from that file into wordlist number 3. When you perform the import command you are told how many items were imported and to which wordlist they were brought. Then type and perform the following commands:
       \!     // make the default presentation nothing
       /3FC   // start doing sequential flashcarding with wordlist 3
       /CW    // clear the workspace
       /X"C:\msw\anahooks.cmd"  // execute commands from the command file
    You will then see several lines get appended the workspace. Then use the /TW command to trim the workspace. This specialized command removes from the workspace all lines which begin with the WHAT?: prompt, all lines which are just " (nothing)%quot;, and one or more consecutive blank lines are replaced by one blank line. For this particular case, the workspace will then appear as:
    ABC
    
     The one blank can be any of these letters: HKRS
    
    DEF
    
     The one blank can be any of these letters: AEILNOSTUY
    
    XYZ
    
     The query did not have 1 or 2 blanks matched by letters.
    
    GHI
    
     The one blank can be any of these letters: HNSW
    
     
    WHAT?: 

    Finally, you may print the workspace, with a command such as:

       /PW"Anahooks Study"

    20.  Printing

    WHAT supports printing the workspace in it entirety with the exception of the last line, which will typically contain your WHAT command requesting the printing. This command is of the form:

       /PW"<print-job-title>"

    where the specification of a print job title is optional.

    There is a File→Print Workspace... menu pick to bring up a dialog where you can specify this title, and you are also provided a couple of printing options which are available to you only in this one place:

    These options in the WHAT "Print Workspace" dialog are what affects the output. There are similar options which appear to be under your control in the "Print" dialog which you see as a result of performing a print command, but the apparent setting of these options are being ignored (in system software, which is a problem beyond our control).

    If you are not adjusting either of these options, you need not use this dialog to form the print command, but if you do, then the print command is appended to the command line in the workspace, and you must then press the Enter key to have it performed.

    When this print command is performed, you are shown a standard printer dialog, which allows you to select a particular printer, control which pages are printed, the number of copies to print, etc. What appears to be offering you the control for collating and printing in reverse order is being ignored, as just explained above.

    The print job title cannot include the quotation mark, and it is limited to 60 characters. The title shows up in two places:

    You can control the font style and size used when printing. You can also control the layout of the printed pages. There are dialogs available via the File menu, and these are also available on the dialog to help you print the workspace.

    Since the entire workspace is printed, you should plan ahead and clear the workspace (using the subcommand /CW) when you are producing output you intend to print from within WHAT.

    Command lines which begin with a space as the first character of your command are skipped when the workspace is printed. Such lines begin with "WHAT?:" and two spaces. Command lines with no contents other than the prompt are also skipped.

    The one-character command of just a minus sign causes that command to be replaced by a line of minus signs. Such a line is not printed when you print from within WHAT, but a page break is made instead. Such lines of minus signs are also included in presented output in the workspace when you are printing in columns and have set a page length.

    When you are preparing the workspace with presentation(s) you intend to print, be sure the width of the presentation width is appropriate for the width of your printed page. With default settings, you can likely get up to 95-character lines printed. If your presentation width is too large, and you are using the default setting that the presentation width is controlled by the workspace window width, then you can adjust the size of the WHAT window such that the workspace window width gets to be what you intend. Alternatively, you can set the presentation width using a command, and you can make use of the GUI to help you construct that command; go to the Max Width box in the Layout box on the Presentation tab, and click on the ellipsis. For further details about these widths, see the "Workspace Size and Line Wrapping" section earlier in the document.

    When you use WHAT to print the workspace, you should be aware about the green blanks you may see in the workspace. By default, letters which are matched by blanks, sets, or wildcards are placed onto the slate in lowercase, and you can control whether this feature is on. You can also control whether lowercase characters in presented words are shown as colored uppercase letters (which is the default) or as lowercase letters. In printed output, these lowercase letters show up as lowercase, so if you want to see how your printed output will appear, you should turn off the option to show these lowercase letters in color (using the subcommand /-LC). As usual, if you want to do this for the long-term, follow that subcommand by an exclamation point. There are menu picks for these options on the View menu. See the section "Case of Letters in Query Output" for further details.

    WHAT may support printing a selected region of the workspace in a future release of WHAT. Please let us know if this is a feature you would like to see.

    Since you may also export the workspace to a file, you can use such output as the basis of having a program such as MS Word set up the print job for you. There is more control of printing from MS Word than is supported from within WHAT.

    21.  Generating Random Racks

    WHAT can be used to act as if it is randomly picking a rack of tiles from a full bag. This can be a useful feature for you to practice. The rack is then brought up on a command line as if it had come from the history. At that point, it is likely you would want to have it load the slate with the answers and be told nothing about the slate. To affect this, you should tell WHAT to show you nothing by your issuing the command:

       \!
    which means until you change this, it will present nothing about the slate on a long-term basis. Then, you might contemplate whether there are one or more bingos in the rack before asking WHAT questions to answer this. You might find it more useful to avoid seeing a full answer right away, but instead ask for whether there is any slate contents (with command ~). You may have then asked whether the slate has some number of words, such as 3 words (with command 3~). Perhaps you may have asked for how many words there are (with command #). A next step might be to ask for the first letter of the first word (with command 1/1), etc.

    By default, WHAT assumes you want 7-letter racks, but you can ask it for a rack of any number of letters (up to 16). If you have WHAT effectively get 7 letters from a full bag of 100 tiles, there is about a 12.5% chance there will be a bingo, and you can use WHAT this way, or you can request that it alters that probability to one you desire. For example, you might prefer to be given racks with an 80% likelihood there is a bingo. On the other hand, you might want to see racks that are poor for bingos and set the percentage to something like 5%.

    The racks are randomly pulled from a full bag, and even that is under your control. By default the set of tiles used is the built-in set (B), and in addition a blank count of 2 is used, but these parameters can be changed. The bag from which random racks are generated need not include all letters, but it should contain, along with a number of blanks at least the number letters in the racks to generate.

    When a rack is presented, there are several possibilities for the canonical ordering. These are described in the earlier "Canonical Ordering" section. Canonical ordering of random racks can be different than the canonical ordering used when presenting canonically-ordered words on the slate, but we suggest you would usually want these to be the same, unless, perhaps, you prefer that random racks be in random order.

    In order to request a random rack as if it were a retrieved command, type the one-character command of the letter R. The one-character command of just a period is like the R command, but an Enter key is automatically "pressed" to perform the command right away.

    Neither of these commands is remembered in the history, but the resulting random rack will be for the period command or for the R command if you then press the Enter key after the random rack is presented.

    The parameters for random rack picking and presentation are set using these commands:

    /.<number>S - number of letters in a produced random rack (2 - 16)
    /.<number>B - number of blanks in the bag for random racks (0 - 12)
    /.<number>P - integer percentage that there is at least one word using all letters (0 - 100); the absence of a number indicates no artificial percentage is used
    /.<number>><wordlist-#>A - append the specified number of random racks to the specified wordlist; during the performance of this command, you are shown its progress in the middle part of the status bar at the lower border of the WHAT window, where each letter shown indicates 10,000 racks have been generated; you may stop this command's performance prematurely by pressing the Esc key, and this will take effect when the next multiple of 2000 racks have been produced
    /."<ordering>" - the random output letter presentation ordering; if you specify no ordering within the quotes, random ordering is used
    /;"<ordering>" - the output letter presentation ordering
    The letters that contribute to a random rack are taken from set (B). This is a built-in set of 98 letters, but you can alter it.

    22.  Challenges

    Since handling challenges is likely to be a common use of WHAT in a club setting, and since the other features of WHAT are also of use in that setting, there are several different methods of bringing up the Challenge Dialog, which is a special window covering the WHAT workspace where you can request challenge rulings:

    WHAT supports the /-? command to ask if one word is in the lexicon. When you want a ruling for multiple words, as is required for a challenged play, you should use the Challenge Dialog. However, if you begin to type some words intended to be challenged to WHAT in its workspace, you may continue by typing either a /C command or pressing the Tab key. In either case, the Challenge Dialog in brought up with the words you included on the command line already entered into the Challenge Dialog. As in the dialog, you may separate words with either commas or spaces. If you give a /C command or press the Tab key on a line with no words, WHAT brings up the Challenge Dialog without initial words.

    Certain lexicons, such as the OSPD4 lexicon, are limited in what words are allowed. The OSPD4 lexicon includes all acceptable words up through length 8, and their inflected forms. For words which are longer than 8 letters, these words must be looked up in both the OSPD4 and another word source (the Merriam-Webster Collegiate 11th Edition). At present, the OSPD4 lexicon does not include words from another source. Therefore, in order not to give players hints, WHAT will decline to make an adjudication when there is at least one word being challenged which is longer than 8 letters, even though it may be possible to make a positive ruling.

    When you use the Challenge Dialog, it takes over the user-program interaction. When you use it temporarily, it covers WHAT's workspace. When you use it in a tournament setting, such that it is able to do adjudications only, it takes over the full screen, including the Windows taskbar. The instructions in that dialog are intended to be sufficiently explanatory that they will not be repeated here.

    The background color of the Challenge Dialog is normally aqua. If you are using the same primary lexicon that was chosen as the WHAT program was started, aqua is the color. However, if you are using a different primary lexicon, the background color is instead fuchsia; this is to alert you that a different lexicon is being used. the fuchsia background color is also used when lexicon transition challenges are enabled. In either case, you can see the short name of the lexicon in the Challenge Dialog, and the long name is also shown in the header line of the dialog.

    Challenged words may be recorded in a computer file as the challenges are being made. It is an option whether such recording is being done. Recording is on by default according to recording period specifications in WHAT's initialization file. The format of these specifications is described in the "Initialization File" section.

    The WHAT initialization files that come with the program has one commented-out recording period specification for times between 6 p.m. Thursday and 1 a.m. Friday, since these hours include the time of the weekly session at the club where we play. You are given control to set up recording period specifications via a dialog, accessible via the menu pick File→Record Challenges Times.... Alternatively, you may edit the WHAT initialization file outside of WHAT, such as by Notepad, EMACS, or MS Word.

    The name of the file that is used for recording is based on the time and date the challenge is being made. A filename prefix is specifiable in the WHAT initialization file, and suffixed onto that prefix is a 6-digit date of the form YYMMDD followed by ".wds". The date for the file name is what the date was six hours earlier. In this way, a late night session yields one file of recorded challenges, as long as challenges stop getting made before 6 a.m.

    These are commands involving challenges:

    /C - with no words in the command, bring up the GUI-oriented Challenge Dialog
    /<unlock-#>C - bring up the Challenge Dialog that will remain active until the secret non-zero, up to 8-digit "unlock number" is typed; if you provide more than 8 digits, only the first 8 matter; challenged words will be recorded here is an example:
    /12345C
    /-<unlock-#>C - bring up the Challenge Dialog that will remain active until the secret non-zero, up to 8-digit "unlock number" is typed; if you provide more than 8 digits, only the first 8 matter; challenged words will not be recorded; here is an example:
    /-12345C
    /C - with one or more words separated by commas or spaces in the command, bring up the Challenge Dialog with the words on this line placed into that dialog for an initial ruling
    /+RC - turn on the recording of challenged words for other than tourney adjudications
    /-RC - turn off the recording of challenged words for other than tourney adjudications

    The use of an unlock number to keep the Challenge Dialog is helpful when using WHAT to rule on challenges in a tournament. This level of control is, however, not strict enough for environments where players cannot be trusted. In order to insure that no cheating is done, a program to field challenges must take over a computer and disallow any other programs to run. WHAT may have this power in the future, but it does not do this today. It can be used only when all users can be trusted not to bring up other programs, such as other copies of WHAT or other word programs on the computer. In contrast, John Babina's Word Judge program, that is used for the National Scrabble® Championships takes over the computer completely, not bringing up an operating system.

    22.1  Automatic Reversion to the Challenge Dialog

    When using WHAT in a club setting, its primary use is to adjudicate challenges. It may also be used when games are over to do some postmortem probing. In order to provide the Challenge Dialog most of the time, you can put WHAT into a mode such that it will automatically revert to the Challenge Dialog after a certain number of seconds of inactivity (using the program for performing commands in the workspace). This is controlled via the menu pick File→Revert to Challenge Ruling. When WHAT starts up, this feature is off, unless challenged words are being recorded. If challenged words are being recorded based on the settings in the initialization file, then reversion is on with a duration of 30 seconds. If you do not want to employ this mode, use the menu pick to turn it off.

    If you choose to turn this mode on directly, you are advised to use a duration of 30 seconds, but there are several choices of durations available, ranging from 20 seconds to 5 minutes. When you are working in this mode, there is an indication ("Auto-revert to Challenge Ruling") in the left section of the status line at the lower part of the WHAT window. The indication does not include the duration being used, but you can see that in the menu pick on the File menu.

    The counting of inactivity time is done only when the WHAT window is active and has focus. Unfortunately, scrolling the workspace is not noticed as an activity to avoid the automatic reversion.

    22.2  Lexicon Transition Challenges

    WHAT can be used to adjudicate challenges to ease players in making a transition from using one lexicon to another. During an interim period, players may want to abide by a rule that there should be no penalty for challenging or being challenged in a play which is affected by the lexicon change. You can turn on this mode of having WHAT perform Lexicon Transition Challenges via the File menu. You can also turn this mode on as WHAT starts up by including a command line argument of -t on the command line. In order for the lexicon transtition challenges mode to have an effect, you must have a secondary lexicon selected, and it is considered as the older (previous) lexicon for these challenges.

    Usually, a challenge is either deemed "acceptable" (using green letters) or "unacceptable" (using red letters), but in this special mode, there are two other possible results, for example:

    These messages are in blue letters, and the ruling remains visible for a duration of 12 seconds, instead of the usual 9, to permit players to read and contemplate the ruling.

    When more than one word is challenged, if any are acceptable in both the old and new lexicons, the play is considered "acceptable". Similarly, when more than one word is challenged, if any are unacceptable in both the old and new lexicons, the play is considered "not acceptable". In both of these cases the usual penalty applies.

    The background color of the Challenge Dialog is normally aqua. If you are using the same primary lexicon that was chosen as the WHAT program was started, aqua is the color. However, if you are using a different primary lexicon, the background color is instead fuchsia; this is to alert you that a different lexicon is being used. the fuchsia background color is also used when lexicon transition challenges are enabled.

    23.  Probe Answer Window

    As of WHAT Version 2.2, there is now support for a user to probe for answers which are for words (or in general, strings) contained in a chosen wordlist or the primary lexicon. Another source of probed words can be from words formable in a Big Boggle® grid. The window where this probing takes place is called the Probe Answers Window or PAW.

    For making general use of the PAW, bring up that window in one of three ways:

    For making use of the PAW to probe for words formable in the current Big Boggle® grid, click on the Probe Answer button in the 5 x 5 Grid Game Player Dialog. You may also bring up the PAW for Boggle® using one of the methods described above. You may then have to adjust one or more options in the dialog to edit PAW options. One of the settings in the PAW Options dialog is whether probing the Boggle® grid is being done.

    When making general use of the PAW, it is placed on top of the tabs at the left of the WHAT screen. In this way both the PAW and the WHAT workspace are shown at the same time. When they are both showing, you can press the Esc key to move focus to the other window. If you close the PAW, then pressing the Esc key will take you to the Challenge Dialog, which is the typcial behavior. You may adjust where the PAW is positioned by dragging it.

    When making use of the PAW to probe for words formable in the current Big Boggle® grid, and when the PAW is brought up by clicking the Probe Answer button in the 5 x 5 Grid Game Player Dialog, the PAW is positoned to the right of the Big Boggle® grid. In this scenario, when you working in the PAW and press the Esc key, the PAW will be closed for the time being.

    You can double-click a probed word in the PAW to see that word's definition, if it has one. The definition is shown in the Definitions area above the workspace.

    You can click the Sort button at the bottom of the PAW to use the current lines in the PAW which have either a plus or a minus or a greater-than sign in column 1 as the basis of producing a sorted list of probes which replace the existing lines. Other lines of the PAW are eliminated. The character in column 1 is ignored as part of what is being sorted. Only the probed words are sorted. This feature is especially useful to a user dealing with seeking words in a 5 x 5 Grid Game.

    When the PAW is closed, its contents are preserved. You can later reopen it to continue using it.

    24.  Flashcarding

    WHAT supports scenarios for presenting virtual flashcards to you and following up with the disposal of these cards into various places. In general this facility is quite powerful in that what a flashcard contains is any WHAT command line. These will typically be a rack in canonical order, such as an alphagram, but that is just one of the possibilities.

    WHAT supports the preparation of word lists for the purpose of flashcarding. You can use a query along with chosen query filtering to gather canonically-ordered words for a wordlist. That wordlist can be exported to a file and later imported back into a WHAT wordlist for flashcarding use. The order of the wordlist resulting from the query may be alphabetical, or sorted by probability or playability, and you may elect to shuffle the wordlist using a command of the form:

       /<wordlist-#>S

    When you are about to deal with flashcarding, you would typically make slate presentations have no output, with a command such as:

       \!
    Then, you can request one of the canonically-ordered words from the list, and WHAT supports two different methods of choosing the item of the wordlist to present:

    That item becomes a command, and the terminating Enter is automatically provided for you. Assuming you earlier instructed WHAT to output nothing for its slate presentation, you can now make various slate presentations, such as asking for the number of words (#) or individual letters of the words on the slate (such as 1/3), etc. After deciding what to do with that flashcard, you can dispense with the flashcard in one of several ways:

    There is one command to support reading flashcards when commands are being executed from a command file. This command may appear only in command files, and it makes sense that it would end a command file, since either it causes a rewind or an exit of the file. This command is:

    /NR - this command is allowable only in a command file; get the next flashcard if any, and if there is one, rewind the command file and continue executing it; otherwise, continue with the next command in the command file

    After getting a candidate from the wordlist, you need not immediately type a toughness command. You could probe the slate, or you could even go on and make other queries. WHAT remembers the last "word" it presented as a flashcard, and so you can type a toughness command much later. You can also bring back the same flashcard using the /FC command. The old "word" is not removed from its wordlist into you type a toughness command, and then it is moved. After you type a toughness command (that is merely an integer), you are presented with a next flashcard. You can continue to work with these flashcards, but when you want to stop, if you want to retain the list as it is, be sure to export it to a file. In a future WHAT session, you can import that same wordlist.

    Perhaps the current flashcard is so easy that you wish to remove it from its wordlist. This is specific instance of the general facility of WHAT to move an item from one word list to another. The general facility also allows for the throwing away of the item. In order to move the current flashcard, use one of the following 1-character commands:

    D - delete the current flashcard, removing it from its wordlist, and prompt with the next flashcard
    X - as a 1-letter command, move the flashcard to the end of the wordlist whose number is one higher than that of the wordlist being used for flashcarding, and prompt with the next flashcard
    Y - as a 1-letter command, move the flashcard to the end of the wordlist whose number is two higher than that of the wordlist being used for flashcarding, and prompt with the next flashcard
    Z - as a 1-letter command, move the flashcard to the end of the wordlist whose number is three higher than that of the wordlist being used for flashcarding, and prompt with the next flashcard
    M - bring up the dialog for deleting, copying, or moving wordlist items

    If the computed destination wordlist is greater than 99, 99 is subtracted from that number to determine the destination.

    Flashcarding cannot be done using the slate (wordlist 0) as the basis, but any other wordlist is a possibility. To keep wordlists from being altered unintentionally, you must explicitly turn on flashcarding as a mode using the

       /<wordlist-#>FC

    command, and when you do this, the fact that flashcarding is enabled is shown in the WHAT status bar at the bottom left of the WHAT window. The mode can be turned off using the /-FC command. Only when flashcarding mode is on is a lone number on the command line interpreted as a toughness. The

       /<wordlist-#>S

    command to shuffle a wordlist can be performed independently of flashcarding mode.

    24.1  Flashcard Preparation

    The previous section described how to use wordlists as the basis for working with flashcards, but it assumed you start with a wordlist of such cards. In general, a flashcard is a WHAT command. The typical command is an anagramming query, such as implied by a set of letters in alphagram or some canonical order of your choosing. But this is not the only kind of a flashcard possible. For example, you may want to have a list of words whose definitions you want to learn. The items in such a wordlist would be likely be in spelling order instead of canonical order.

    You might want to quiz yourself on extensions to words, such as what are the 3-letter prefixes for QUATE. In this case your flashcard would be something like

       ...QUATE
    or
       3.QUATE
    Such items may be members of wordlists, despite the fact they are not really words. An item of a wordlist being used as a flashcard is in general one WHAT command; it may even include a comment as part or all of the item.

    WHAT can help you make wordlists consisting of words in spelling order or canonical order. If you would like to get fancier, you should use a text editor, such as Notepad, Emacs, or MS Word, to prepare such text files.

    Here an example of how to prepare a set of flashcards for studying likely seven-letter words:

    25.  Playing the 15 x 15 or 21 x 21 Grid Game

    The info about this topic is covered in a separate document entitled "what_with_scrabble.html".

    26.  Playing the 5 x 5 Grid Game

    As of the release of WHAT Version 2.2, this section describing support for playing this game has been moved to a separate document and enhanced to include new features; see WHAT about Boggle®.

    27.  Playing the Word-Building Game

    This feature relates to a a game which has shown up on TIVO systems, where an individual (or collaborative group) builds up words of length 3 - 12 from a grid of 8 rows of 12 columns of tiles. This game is named Wordsmith, as it appears on the TIVO system, and WHAT supports a very similar game. Support is for English, French, and Spanish tiles and lexicons. The 5 x 5 Grid Game described in the previous section is supported only for English.

    You can bring up the Word-Building Game Dialog in one of three ways:

    Typically, you have WHAT form a random grid for you, although you can import grids from outside the program. You can also bring back grids which you have dealt with during this WHAT session. WHAT also allows you to provide you own grid. It will warn you if you create a grid that does not have the standard distribution of the tiles, but you are permitted to play with such a grid. WHAT's standard 96 grid tile distribution has less tiles than are found as the non-blank tiles in a standard English, French, or Spanish Scrabble® sets. For English, the omitted tiles are one I and one O. For French, the omitted tiles are one A, two E's, and one U. For Spanish, the omitted tiles are one G and one H.

    In playing the game, you select tiles from the top row of the grid to place up into the box where you are forming a word. As you contribute these tiles, you are warned if what you are forming cannot lead to an acceptable word in the lexicon. When you indicate you have completed a word, it will be accepted only when it is acceptable in the lexicon. You may retract your plays, including retracting your formed words. The object is to score well with all the words you are making. A word is scored by multiplying its length times the sum of the individual scores on the tiles in that word. So, the best possible score is achieved theoretically by playing eight 12-letter words. Being able to do this is likely to be impossible. Very good computer-found solutions will have about 10-12 words and can score well above 1500.

    As you are playing you are shown the words you have formed and also how long it took you to find these words. When you end a game, either because you can find no more plays or if there are too few tiles left, the unplayed tiles do not affect the total score. If you want, you can record your game in a history file, or you can export it to a file of your choosing. The recorded game includes the grid, the words played, and the columns from which you chose each letter. The solving times are not remembered in the history.

    When importing and exporting Spanish grids, or when specifying your own grid, the digram Spanish tiles are signified by digits 1, 2, and 3 for CH, LL, and RR respectively. When specifying your own grid via the dialog, you may also indicate these digrams by typing Ctrl+C, Ctrl+L, or Ctrl+R. Tilde-N can be signified by that very character, and you can specify one during your own grid specification by typing Ctrl+N.

    It is intended that WHAT will provide some solving power to produce a good, but probably not optimal, solution for a given grid. This is currently being studied and developed, and it seems to be a very difficult programming problem to find an optional solution in a reasonable amount of time.

    To see more details on how to play this game, click the Help button in the Word-Building Game Dialog.

    The source of words used for playing this game is the current primary lexicon. If you have changed the word source to a wordlist, that does not affect the source for this game.

    You can close the dialog and reopen it later, coming back to where you left off. Switching a lexicon from English/French to Spanish or vice versa while you are in the midst of a game or with a current grid causes confusion, but you are warned about this when you do this as you resume the Word-Building Game Dialog. If you want to play a game using a different lexicon, you should clear the current grid and start again. You can also leave things as they are, and return to playing once you have changed the lexicon back to the same kind it was when you started.

    28.  Starting WHAT

    You can start the WHAT program by double-clicking its icon, or you can invoke it from a DOS prompt. If your current working directory is where WHAT.exe is, you can merely type the command:

       what
    or if you are elsewhere, type the path to the executable file and end with "what". Following "what" you may supply an argument to the program to direct it to use a specific initialization file other than what.ini, using a DOS command of this form:

    what -i <filename>

    Similarly, you may supply an argument to the program to direct it to begin by executing a particular command file, using a DOS command of this form:

    what -x <filename>

    You may supply a command line argument of -t to the program to direct it to turn on lexicon transition challenges as it starts up.

    28.1  Initialization File

    When WHAT starts up, it reads and processes the file what.ini that it seeks in the current working directory. This file specifies installation-specific data for WHAT. The file is organized into sections, and each one begins with a short uppercase phrase within square brackets. Blank lines and lines that begin with a minus sign or number sign are ignored, and thus a line of several minus signs is a visually good inter-section separator. Following each section heading line are one or more lines of data. Look at the what.ini file on your computer to see an example of the contents of this file.

    There is an optional command line argument of -i followed by a filename, which can be used to tell WHAT a specific initialization file to use.

    Rather than reporting detected errors in the initialization file, WHAT ignores lines with errors. This will not be much of a problem, since it is WHAT itself which creates initialization files. If users find this behavior lacking, please inform the author.

    28.1.1  [LEXICONS] Section

    The [LEXICONS] section of the WHAT initialization file has one or two lines of data. The first line has 4 fields separated by a space: the number of the primary lexicon, the number of the secondary lexicon or 0 for none, an indicator of how to mark words in or not in the secondary lexicon, and the character to be used as such a marker. The values of the third field are:

    The indicator is a suffix character immediately following a word in slate presentation. Such indicators are not shown in the results of two-word anagrams or two-word patterns.

    The optional second line of this section has the number of the lexicon to be used for challenges. In the absence of this line, the challenges lexicon is the same as the primary lexicon.

    Lexicon numbers are assigned when each lexicon file is created by the WHAT development staff (i.e., Mike Wolfberg). Each file includes the information as to what its number is. You need not get involved with this numbering, since you can create a new initialization file via WHAT, and it will fill in the correct numbers.

    28.1.2  [DEFINITIONS] Section

    The [DEFINITIONS] section of the WHAT initialization file is used to supply a path of an optional file of definitions. At present, you may specify only one such file, and this is not a per-lexicon file. It is not considered an error for the specified file to be missing.

    28.1.3  [PLAYABILITY] Section

    The [PLAYABILITY] section of the WHAT initialization file is used to specify a path of an optional file which can be used for WHAT to use as the basis of assigning a playability number to a word. Also in this section, whether the feature is enabled as WHAT starts is specifiable; in order to have this be the case, the section should include

    YES

    28.1.4  [WORKSPACE FONT] Section

    The [WORKSPACE FONT] section of the WHAT initialization file specifies the font WHAT initially uses in its workspace. The default value for this is "Courier New".

    28.1.5  [WORKSPACE FONT SIZE] Section

    The [WORKSPACE FONT SIZE] section of the WHAT initialization file specifies the font size WHAT initially uses in its workspace. The default value for this is 16.

    28.1.6  [WRAP WORKSPACE LINES] Section

    The [WRAP WORKSPACE LINES] section of the WHAT initialization file, if present, has one data line which should be either ON or OFF. This indicates whether long lines in the workspace are wrapped to the next line. In the absence of setting this parameter in the initialization file, the default is that wrapping is on.

    See the "Workspace Size and Line Wrapping" section earlier in the document.

    28.1.7  [WORKSPACE COLORS] Section

    The [WORKSPACE COLORS] section of the WHAT initialization file specifies the colors of text and background in the workspace, and the color used for blank designation is also specifiable. Unless otherwise changed, the defaults for these colors are text is white, the background is black, and the blanks are lime green. The format for individual lines in this section are:

    The choices for column 1 signify Text, Background, and Blanks.

    28.1.8  [RECORDING FILENAME PREFIX] Section

    The [RECORDING FILENAME PREFIX] section of the WHAT initialization file specifies the initial part of a path for the name of the file to be used to record challenged words. When the specification has no path punctuation (slashes or a colon), files are created in the directory known via environment variables HOMEDRIVE and HOMEPATH. On an XP system, this is usually directory: C:\Documents and Settings\<user-name>. On a Vista system, this is usually directory: C:\Users\<user-name>.

    As an example, the spec WHAT author, Mike Wolfberg, uses is

    C:\msw\sc\ratings\sc
    which means a file created on September 23, 2014 would have a name of
    C:\msw\sc\ratings\sc140923.wds

    This section must precede the [RECORDING PERIODS] section in the initialization file.

    28.1.9  [RECORDING PERIODS] Section

    The [RECORDING PERIODS] section of the WHAT initialization file indicates those times during a week or month when the recording of challenged words is on by default. The format of individual lines of this section are either just one line with

    ALWAYS
    or a line of the form

    <day-spec><2-column-from-hour>,<hours-of-duration>

    These are the allowable day-specs:

    <nth> is one of: 1ST, 2ND, 3RD, 4TH, 5TH, ALL, <3-spaces>

    ALL and <3-spaces> are equivalent.

    <day-of-week> is one of: SUN, MON, TUE, WED, THU, FRI, SAT

    To support evening play, such as in clubs, four hours are first subtracted from the real time to be the basis of naming the file used for recording challenged words. The from-hour should be a 2-digit hour, where hours are between 00 and 23, and the hours of duration are specified as an integer less than 25. A start hour less than 6 is assumed to be 6, and an end time past 6 a.m. is assumed to be 5:59 a.m. As described in the "Challenges" section, files for recorded challenges are named based on what the day was six hours earlier.

    For a club that meets from 7 p.m. every Thursday, the following spec makes sense, especially if challenges may occur somewhat earlier than the official start time:

    ALL THU 18,10
    The duration of 10 hours is much higher than necessary, but it should not cause any false recording, since that represents an ending time of 4 a.m.

    If you have requests for other time specifications, please make this known to us.

    This section must follow the [RECORDING FILENAME PREFIX] section in the initialization file.

    28.1.10  [CHALLENGE REVERTING] Section

    The [CHALLENGE REVERTING] section of the WHAT initialization file, if present, consists of optional lines which each affect settings involving the feature that the Challenge Dialog will be brought up automatically after a period of user inactivity. These are the possible lines:

    28.1.11  [PRINTER FONT] Section

    The [PRINTER FONT] section of the WHAT initialization file specifies the font WHAT initially uses when it prints the workspace. The default value for this is "Courier New".

    28.1.12  [PRINTER FONT SIZE] Section

    The [PRINTER FONT SIZE] section of the WHAT initialization file specifies the font size WHAT initially uses when it prints the workspace. The default value for this is 10.

    28.1.13  [PRINTER PAGE SETTINGS] Section

    The [PRINTER PAGE SETTINGS] section of the WHAT initialization file specifies six values which affect the layout of printed pages when WHAT prints the workspace. The one data line has six integers separated by spaces:

    These last two data have no effect when not printing a header or footer, but these values are retained even when that is the case.

    28.1.14  [LEFT TABS] Section

    The [LEFT TABS] section of the WHAT initialization file, if present, consists of one data line which should be one of the following: QUERY, PRESENTATION, or NOVICE, or NONE. In the absence of this section NOVICE is assumed. This controls which tab if any is showing when WHAT begins. A new user is shown the Novice tab, but then it is likely that most WHAT users will prefer to show the Query tab on a regular basis. On the other hand, if you want to run WHAT without the left tabs showing in order to be able to have a small pixel density, such as 800 x 600, then you would be running the program with no tabs showing. Making this choice is a tradeoff among usefulness, screen density, and screen clutter.

    When you choose to show the Query or Presentation tab, four graphical buttons near the Challenge button appear; they are hidden when the Novice tab is showing. If you elect to not show the left tabs, which tab is active when you make that menu click will affect whether the four graphical buttons show for the current session. When WHAT is freshly started, if the initialization file indicates there are no left tabs, then those four graphical buttons are not shown either.

    If you run WHAT on a screen with a small pixel density, such as 800 x 600, it will run without showing the left tabs, independently of what this [LEFT TABS] section specifies.

    28.1.15  [DEFAULT DIRECTORY] Section

    The [DEFAULT DIRECTORY] section of the WHAT initialization file specifies the default directory WHAT uses when a user opens a file for input or output, such as to read or write a wordlist.

    28.1.16  [FUNCTION KEYS] Section

    The [FUNCTION KEYS] section of the WHAT initialization file can be used to specify meanings of the various function keys, F1 though F12, except not F10. There are two options for each of these keys:

    These options are indicated as part of each data line in this section, whose format is:

    At present, a function key cannot represent the inputting of more than one line.

    28.1.17  [TIMER SETTINGS] Section

    WHAT supports keeping track of time duration and indicating when the timed period is up. See the Timer tab at the upper right corner of the WHAT window. The settings for the timer can be set up in the WHAT initialization file. Individual lines in this section are optionally:

    28.1.18  [PREMIUM SQUARE COLORS] Section

    The [PREMIUM SQUARE COLORS] section of the WHAT initialization file specifies the colors of the premium squares on the board used when playing the 15 x 15 or 21 x 21 game. The defaults for these colors should be good enough, but in case users might want to make changes to these, those changes can be made more permanently. The format for individual lines in this section are:

    The choices for columns 1-3 signify choices such as DLS for Double-Letter Square.

    28.1.19  [HOOK SEPARATORS] Section

    The [HOOK SEPARATORS] section of the WHAT initialization file can be used to specify the separators to use when front and back hooks are included in presented output. Individual lines in this section are optionally:

    28.1.20  [PROBE ANSWERS] Section

    The [PROBE ANSWERS] section of the WHAT initialization file can be used to specify settings of the options for the Probe Answers Window (PAW). Individual lines in this section are optionally: