Personal Project 

Creating a Scrabble‐playing application 
created by:
Konrad Komorowski

supervised by:
Anita Pawłowska

02.03.2007
Gdynia Bilingual High School No 3
and International Baccalaureate School No 0704
 Table of Contents 
Introduction ............................................................................................................................................. 3

Description of Process ............................................................................................................................. 4

Inspiration............................................................................................................................................ 4

Planning ............................................................................................................................................... 4

Choosing the tools ........................................................................................................................... 4

Learning Java .................................................................................................................................. 6

Development of the program ............................................................................................................... 7

General idea..................................................................................................................................... 7

Word list .......................................................................................................................................... 7

Construction of the program............................................................................................................ 7

Future prospects .................................................................................................................................. 9

Licensing the work .......................................................................................................................... 9

Propagating the work..................................................................................................................... 10

Further development...................................................................................................................... 10

Analysis of the inspiration, research and influences guiding the work ................................................. 12

Conclusion ............................................................................................................................................. 13

Bibliography .......................................................................................................................................... 14

Appendices ............................................................................................................................................ 15

2
Introduction 
The purpose of my Personal Project is to create a Scrabble-playing application,1 i.e. a program with
which one would be able to play Scrabble. I decided to choose this subject firstly just because of the
fact that it is a demanding goal and I simply like challenges. Secondly, it can still be something of real
use, because there are a lot of people who like playing Scrabble and sometimes do not have the
opportunity to do so if it is impossible to contact other people with the same interest. Last but not
least, designing and algorithm playing a game requires a lot of skills in the area of logic, which is one
of my interests. The exact topic however didn’t derive from those three outlined reasons. It was more
like an idea that popped into my head quite of its own accord and was accepted because it perfectly
fulfilled the requirements I had towards my Personal Project goal.

The goal of my Personal Project is to create an application. Usually, this process of creation should be
the one guiding my work. Consequently, Man Creator – the Homo Faber Area of Interaction could be
considered the one giving shape to my whole project. However, a very important factor is the fact that
I do not know yet any computer programming language, which is absolutely indispensable in my
work. As a result, my project gains a second task – the learning of programming. Thus, it will not only
check my abilities of making a program, but also firstly learning how to do it. Approaches to Learning
will be the key factor determining the success or failure of my work. To conduct it smoothly, and
simply without any unnecessary problems, I will have to find a reasonable consensus between the
creation of the program as such and gaining skills essential in carrying out this task. Should I succeed
in it, it could prove a product profitable not only for me, by giving the useful experience, but also for
the community, by providing a free, and hopefully convenient, way of playing Scrabble with the
computer.

The goal of my Personal Project is clearly stated, so are the actions I have to take in order to achieve it.
The first thing I will have to do is to work out a general idea of how the program is going to look like
and work. Being able to consult original Scrabble manual would be a very useful aid in it. Then I will
have to choose a specific programming language in which to program my work. At the beginning of
my work I didn’t know any of those, so after choosing one the next step would be mastering its basic
usage. Finally, after all the preparation I would have to simply code my program and make it somehow
available to wider public, preferably by publishing on the Internet.

1
Scrabble – a popular word game and board game in which 2 to 4 players score points by forming words from
individual lettered tiles on a 15-by-15 game board. The words are formed across and down in crossword fashion,
and must appear in a standard dictionary. From http://en.wikipedia.org/wiki/Scrabble.

3
Description of Process 

Inspiration 
I first came to the idea of producing a Scrabble-playing application on 30 April, 2006. While talking to
my parents’ friend I learned about various computer programs that provide an aid in playing Scrabble.
The application I was told about showed possible words that fitted a provided regular expression2. I
had just finished coding a very simple Java program then – a school assignment. Therefore, I thought
about extending the possibilities of such a program by coding an application that would be capable of
analysing the whole gameboard and showing the player all the possible moves they can make (of
course given the player’s tiles). Then I realised that coding such and application would virtually mean
doing the majority of work needed to produce a fully functional Scrabble-playing application. By that
time I had been already informed about the need to choose a Personal Project topic. As a result I chose
to code a Scrabble-playing application for my Personal Project. I started to think about the engine of
the game right away. I came up with quite a lot of ideas, but looking from a wider time perspective, I
eventually didn’t use majority of them, if any.

Planning 

Choosing the tools 
After the primary stage of unordered ideas about the project I had to do some more serious work.
Precisely, I decided to choose the programming language and the software in which to code the
program.

Programming language 
Generally speaking computer cannot understand human logic and vice versa. Computer processors
operate in bits, which are variables that have the value of either 0 or 1. The CPU3 is capable of
operating those values extremely fast. However, despite being able to make billions of calculation per
second, the CPU is quite simple. It can be told what to do only using its machine code – a set of
particular uncomplicated instructions perfectly understood by it. However, the machine code is not
human-readable. Although it can be understood after careful study of the processor’s construction,
trying to design complex actions writing them directly in the machine code would be extremely
inefficient. Moreover, every type of CPU has a different structure – understands different machine
code, so the programs either would have to be written separately for different architectures4 or we
would have to restrict ourselves to only one type of CPU. What a terrific loss of opportunities of
development and competition in the computer industry it would have been!

2
Like: show me all the accepted words that begin with W, then have any letter, then U, then either L or N and
then D – “w.u[ln]d”. The application would return would and wound.
3
Central Processing Unit
4
CPUs types

4
That is why more abstract computer languages like Java, Python, C++ or C# have been designed. They
are completely incomprehensive for the CPU, but humans, possessing the ability of abstract thinking,
can read and write in them. The code produced by humans is then translated by compilers into the
machine code, which can be then executed by the CPUs. However, the machine code itself cannot be
modified by human beings, as it is simply unintelligible for them. Only by being given the abstract
language code of the program other people can edit it, and then compile and run by themselves. This
abstract language code of the program is called the source code and the already compiled program – an
executable file.

Programming languages possess different levels of abstractness. The general rule is that the more
abstract a language is (the higher-level language it is), the less efficient it is. The human does not
directly design the processor’s actions but let them be automatically transformed into machine code by
a non-intelligent compiler. Therefore the less control the programmer has over the basic parts, the
fundaments of the program, the more is handled by a non-intelligent compiler, what inevitably leads to
a loss of efficiency. Old and traditional low-level languages like C are not as abstract as the newer
high-level ones, such as for instance Python. Consequently, low-level languages are more efficient
than the high-level ones but require greater knowledge of the construction of a computer and in almost
all cases require more coding to design a specific action.5 6

At the time of April the 30th I had already had some lessons on the Java programming language – quite
a specific high-level language.7 I had even bought a book on Java, Praktyczny kurs Java8, which I
hadn’t read yet then. After a few weeks of consideration I decided to choose Java as my programming
language because:

1. It is high-level – programming in it doesn’t require that much knowledge about the work a
computer. I decided to sacrifice the efficiency in return for considerably shorter and easier
process of learning the language and coding the program.

5
So there is a possibility that a poor low-level programmer can still do worse than a wisely designed high-level
compiler.
6
This is of course a simplification. Computers’ work is much more complicated than simply writing source code
and compiling it for the CPU. Many solutions are adopted in order to increase the efficiency and usability of
computer systems, which are far too complicated to discuss in this work.
7
The specificity consists in the fact that it is generally practised that the Java source code is not directly
translated into the machine code. Instead, it is translated into beta-code – a halfway stage between human-
readable code and machine code. Additionally, there is such a thing as Java Runtime Environment whose most
important part is the Java Virtual Machine. JVM is capable of translating the beta-code into the machine code of
the CPU on which it is working. JREs are produced for many operating systems and CPU architectures. As a
result, the programmer doesn’t have to compile their code for different architectures – beta-code will work on
any operating system, provided that there is a JRE for it. This universality makes Java multi-platform, but also
negatively affects its efficiency.
8
pl. Practical Java course, listed in the bibliography

5
 2. It is multi-platform – I was planning a Windows to Macintosh transition at the time, so
choosing Java would make the switch smooth and allow me to code on Macintosh a program
that could be easily executed by anyone running the most popular Windows.

I had enough knowledge to make this decision because I was already quite interested in the computer-
related topics.

Development environment 
Source code of a program is just a sequence of characters; usually interpreted by the compiler (other
possibilities are for instance a Virtual Machine, as in Java, or an on-the-fly interpreter, as in some
script languages like Python). So, theoretically, a program could be written in simple text editors like
Mac OS X TextEdit or Windows Notepad. However, writing every line of code on one’s own, without
the help of any additional features is tiresome and ineffective. Those features include a quick, one-
shortcut compilation of the program to check for errors quickly, smart management of already
produced parts of code to be able to easily refer to them later on etc. Programs that have such features,
and are usually designed to work with specific programming languages, are called IDEs.9 The IDE that
I was told by my computer science teacher to use was free jCreator10 (see Figure 1). I personally didn’t
feel comfortable with it. This could have been caused by the fact that I virtually didn’t know how to
program in Java. Nevertheless, when I visited a Polish social networking website – Spinacz11, I found
out on the Java-related group’s forum that the most praised Java IDE there was Eclipse12 (see Figure
2). It was also a free product, even more – and open source13 project, that was used by many experts. It
had a professional and clear look, its functions were intuitive. In simple words, I liked it from the very
beginning. Additionally, because the fact that it was open source, Eclipse was ported by many
individuals to work on different operating systems. That said I could code with the same program on
Windows, Linux, FreeBSD and Mac OS X. Having considered it and found on the Internet many very
positive opinions about Eclipse I chose it to be my IDE.

Learning Java 
I decided that I do not have enough time to learn Java and then start my project. Instead, I took another
strategy. I quite carefully read the whole Practical Java course in about a month, which wasn’t a most
demanding lecture – only an introduction to Java programming. I also bought two other materials by
the same author – Java. Pocket lexicon and Java. Computer science tables. Knowing the very basics of

9
Integrated Development Environment
10
http://www.jcreator.com/
11
http://www.spinacz.pl/, pl. paper clip (a reference to linking people each other)
12
http://www.eclipse.org/
13
Open Source Software is software for which the underlying programming code is available to the users so that
they may read it, make changes to it, and build new versions of the software incorporating their changes. There
are many types of Open Source Software, mainly differing in the licensing term under which (altered) copies of
the source code may (or must be) redistributed. http://domainsmagazine.com/managearticle.asp, accessed via
Google definitions search.

6
Java I started coding my Personal Project as in fact the second Java program bigger than 50 lines of
source code in my life. At the same time I ordered a very advanced book on Java – Thinking in Java
by Bruce Eckel. It is more than 1200 pages long so reading through all of it in the course of my last
MYP school year would be virtually impossible. I decided that I would consult the book only if I had
any doubts or problems concerning my program.

Development of the program 
The next step after the necessary planning and preparation was the Project itself – coding the program.
I will not present designing the full engine here, as it far too complicated to present within the volume
limit of the work. The whole process is described in the log book.14

General idea 
The general idea I tried to follow while coding my program is the following: the application is
constantly aware of every single word15 that can be put anywhere in the gameboard, in compliance
with the Scrabble rules – from now on called in my work a potential input. Then, when one of the
computer players turn comes, the AI16 of the application will run through all of the potential inputs and
check which of them can be inserted using the tiles possessed by the AI player on whose behalf the AI
is working. Then, it will assess the possible moves according to a given, mostly based on the move’s
score, key. In case of a turn by a human player, the application will simply check if a given word
exists in its current database, without analysing the move as such.

Word list 
For my application to be able to check if given words exist in the English language I had to find a
dictionary whose license would allow me to use it in my program without the need to pay anyone.
Using the Google search I found a webpage about Miscellaneous Shareware and Freeware,17 where
some English words lists were presented. I chose the longest available – YAWL 0.3.218, containing
about 264,000 American English words.

Construction of the program 

Possible inputs database 
For the database of all the possible inputs to be constantly up-to-date I acquired the strategy of
instant updates, i.e. every action affecting the gameboard – inserting new tiles – would make the
program recalculate the potential word inputs in specific places of the gameboard. I had to very
carefully design the algorithm for chooses places in which to look for potential inputs updates, for the
program to cover all the possible updates, but under no circumstances rescan the whole

14
The frequency of entries is falling towards the end of the project due to extensive amount of school work.
15
However, still not longer that the specified tiles per one player number limit.
16
Artificial Intelligence
17
http://personal.riverusers.com/~thegrendel/software.html
18
An abbreviation for Yet Another Word List, unfortunately it doesn’t seem to have any official website.

7
gameboard, because such an action would lengthen the computers calculations to an unacceptable
scale. I managed to write an optimal algorithm for finding such potential updates, whose exemplary
work is presented in Figure 3. (The red word is the newly inserted one, green fields are fields at which
begin potential new vertical words that need to be updated, blue are analogical but refer to the
horizontal potential words and the red fields combine both horizontal and vertical updates. Note that
for instance potential 4 letters long vertical words beginning at row 1 and column 7 do not need to be
updated. Such improvements are included in my algorithm.)

AI’s input choice 
As planned, I coded the AI of the game so that it runs through all of the possible words, checks which
inputs can be made by a given player and then assesses each of them. I design a special formula to
assess the value of a given input:

· ·
∑ ·∑

( – the value of an input, – score of the input, – the number of tiles used, – value of a given one
tile of the input19, – number of occurrences in the dictionary of a given one letter of the input20, –
the number of tiles left in the sack, – the total number of tiles in the game)

The idea behind the formula is that score matters the most (risen to the power of 6). Then, the better

tiles are used (on average!), the less valuable the input is (the multiply by ∑ part). However, this
·∑

matters less and less, as the game progresses (the fewer tiles are left in the sack the more the multiply

by and add part brings the value of ∑ to meaningless one).

·∑

User’s input validation 
As in the plans (however unlike the very first plans), the approval of users’ moves also relies only on
the existence of the move in question in the possible inputs database.

Program­user interaction 
After coding the engine of the game I had to design the system of user’s interaction with the
application. I choose not to develop a Graphical User Interface because of one main reason – lack of
time. If I had wanted my application to have a GUI I would have had to firstly learn how to do it, then
design the interface and code it. This would take definitely too much time. So I decided that my
program would be a command line application. Basically, it means that my program would
communicate with the user using only text commands. (See Figure 4 for a sample application-user
interaction.) I also designed a few commands non-essential in playing Scrabble that can prove useful

19
The higher, the more valuable.
20
As above.

8
during the game. For a list of all the commands with explanation see Figure 5 – the output of my
program’s help command.

Future prospects 

Licensing the work   
When I had finished the product itself I had to choose an appropriate license for its source code. My
primary assumption was that the program would be open source, i.e. I would make the human-
readable Java code freely available along with the end-user specific Java beta-code. As a result,
anyone interested in my project would be able to check how every aspect of the application works and,
if they wished to, change anything for their needs. I made it possible because I had no intention of
selling the software. I considered my work an educational, not commercial project. So, as I didn’t need
to protect my programming solutions from the eyes of other people (to control the development of the
application and make profit out of it), I decided that in fact I didn’t need to protect my programming
solutions anyhow. So I made every bit of the source code open for everyone.

In the world dominated by the idea of management of the so called intellectual rights, it is an
established custom to make the source code available under a given license. There are hundreds of
such licenses, each of them imposing different duties and limitations upon the user of the licensed
source code. In the open source community there are two dominating licenses: BSD and GPL.

Berkeley Software Distribution License 
Generally speaking, this license stresses that the author of the code is not responsible for any problems
caused by the software. It doesn’t prohibit redistribution of the modified code without the source
code, thus makes it possible to use the code in commercial products. See Figure 6 for the full text of
the newest version of the BSD License.

GNU Public License 
The most significant difference between GPL and BSD is that every program based on a GPL code
has to be redistributed under the terms of GPL. The terms hold that the program is distributed with
its source code, so consequently GPL code cannot be used in any commercial work. See Figure 7 for
the GPL summary.

Massachusetts Institute of Technology License 
The MIT license is based on the BSD license, but has most of the clauses removed, the whole text
simplified and a clearly stated permission for selling and relicensing the software. See Figure 8 for its
full text.

9
Final choice 
I decided that the MIT License is the most appropriate one. GPL is hypocritical, with its authors
claiming that intellectual property doesn’t exist and still imposing on the code users very strict clauses.
On the other hand, BSD License is very liberal, what fits my views on the intellectual property. MIT
License, as a further simplified BSD License is in my opinion the best license choice for a clear and
just software.

Propagating the work 
To propagate the work I prepared a webpage about it (see Figure 9). I called the program jScrabble21
to be possible for it to be recognised by potential users. I used the Google Page Creator22 to create the
layout, Google Apps for Your Domain23 to host it and my domain kundziad.net to make the official
WWW address of my page – http://jscrabble.kundziad.net. The page has information on running the
software, every version of the program I have produced and some contact information to me – my e-
mail and Jabber ID.

Further development 
My application is in the early stage of its life. Just after being produced, some features are not
optimally developed yet, some are missing and some are simply obsolete. To determine what should
be changed in my program I would have to make it available to the wider public, gather some
feedback from the users and then decide how the program should be improved.

However, even now, I can say which sections need some additional work on them:

1. The speed of the program needs improvement. I have identified the problem as associated with
the regular expressions libraries.
2. The configuration of the program should be more flexible. From the point of view of the
architecture of the program it is not difficult to do, as the crucial variables determining the
operation of the program are located in one place. Though, the user should be able to control
all of them by changing only the configuration files, not the source code.
3. The above mentioned files should be well documented, for an end-user to be able to modify
them for their needs without any problems.
4. My application doesn’t allow the player (neither human, nor AI) to replace their tiles with the
ones from the sack. Replacing tiles is a vital part of the Scrabble game and should be
definitely implemented in my game.
5. It is not possible to check the values of specific letter from the level of the application. The
user must have an access to either a physical Scrabble game or the Internet to check those
values. Although theoretically they can do it by reading the configuration files, it is not a
21
j stands for Java
22
http://pages.google.com/
23
http://www.google.com/a/

10
convenient way of doing so, therefore a feature of showing the letters values should be
implemented.

11
Analysis of the inspiration, research and influences guiding the work 
I managed to achieve the goal I set myself at the beginning of the project. This was possible because
of the fact that I tried to follow strict procedures, which were guided by the Middle Years Programme
Areas of Interaction.

As I didn’t know how to program in Java before this project, the main problem met during its
development was learning this programming language. The approach I took towards this task was
relatively uncommon. However, deciding to actually learn the language in course of the work on the
application can be now perceived to have been a good choice, which had saved me quite a
considerable amount of time. Not only was my project is strictly connected with technology as such,
but I had also applied it in the area of cooperation with my supervisor. A very good example may be
the constantly available on the Internet logbook, which could be accessed by my supervisor at any
time to check my progress on the work. An interesting remark I made during the project is that despite
my profound interest in all the computer-related matters and even the nature of the project, the most
reliable sources I used virtually all the time were paper books. It is a very important thing to appreciate
the value of a well-checked, carefully designed source of information the Internet is not able to fully
provide at this level of its development, at least still in some areas, ironically computer science being
one of them. The conclusion is that firstly paying for knowledge in many cases will mean value for
money and secondly that Internet is not yet an indispensable medium, despite my immense admiration
for its great design and community.

12
Conclusion 
The most important thing concerning my Personal Project is the fact that I managed to produce it. It
simply meets the demands it was appointed – it is possible to play Scrabble with my application. I
must admit that finishing the whole task (and many smaller tasks set up within the frames of the
Personal Project) gave me a lot of satisfaction. This feeling of achieving a very hard goal, many people
assured me was too hard for me, is certainly what made the project worth doing. Basically, I can now
say that I truly know what is hidden behind the idea of Homo Faber, the leading Area of Interaction
present in my Personal Project.

Though, the satisfaction derived from the work is not the only positive effect my project has caused.
The potential social meaning of it should be considered. Starting from the basics, it is not only free but
also open source, so all the code I wrote can be reused in any other non-commercial or commercial
project, under the very liberal terms of the MIT License. Secondly, computers are taking over
increasingly big parts of our life. As a result, traditional games are replaced by their new computers-
based equivalents. Sometimes the new ones are as valuable as their predecessors, computer Role
Playing Games may serve as an example, though very often the today’s generation games are simply
less and less demanding or developing. Therefore, creating a Scrabble-playing application may be seen
as an attempt to make traditional games once again attractive to the younger generation, of which I am
obviously a part.

However, the social significance of my product should not be exaggerated. It is still a not very
efficient and in fact amateur piece of software. The AI is quite simple and the general performance of
the application, as far as its speed is concerned, is poor on slower computers. It is obvious, because I
simply am not a professional programmer. Therefore, the focus on the Community and Service aspect
of my work could be considered really significant if the program had real use, i.e. was a truly good
piece of computer software. Though some of friends to whom I have shown the program admitted that
they really enjoyed playing the game, so some goals in the CaS area of my work have been surely
achieved.

Concluding, I must say that my Personal Project, although unfortunately not having much real-life use,
has been a really developing task for me. It helped me in improving my logical thinking skills.
Explaining the work of the game’s engine made me express my thoughts and ideas in a more
comprehensive way. Finally, managing to do the work assured me that I am able of achieving the
goals I set myself. This is what gave me the highest satisfaction and made my Personal Project
worthwhile.

Word count: 4211

13
Bibliography 
Eckel, Bruce. Thinking in Java. Trans. Przemyslaw Szeremiota. 4th ed. Gliwice: Helion, 2006.

Lis, Marcin. Java. Leksykon Kieszonkowy. Gliwice: Helion, 2005.

Lis, Marcin. Praktyczny Kurs Java. Gliwice: Helion, 2004.

Lis, Marcin. Tablice Informatyczne. Java. Gliwice: Helion, 2004.

Shavor, Sherry, Jim D'anjou, Scott Fairbrother, Dan Kehn, John Kellerman, and Pat McGarthy. Java
Developers Guide to Eclipse. Trans. Adam Bochenek, Piotr Rajca, and Jaromir Senczyk. Gliwice:
Helion, 2005.

14
Appendices 
A screenshot of the jCreator development environment working on Windows .................................... 16 
A screenshot of the Eclipse development environment working on Mac OS X ................................... 16 
Potential word inputs to be updated after inserting a new word on the gameboard .............................. 17 
A sample user-application interaction ................................................................................................... 17 
A list of commands available in the program ........................................................................................ 18 
The BSD License .................................................................................................................................. 18 
GNU General Public License summary from Creative Commons........................................................ 19 
The MIT License ................................................................................................................................... 19 
A screenshot of the application's website – jscrabble.kundziad.net ...................................................... 20 
A screenshot of a sample human player turn on Mac OS X.................................................................. 21 
A screenshot of one game’s results on Mac OS X ................................................................................ 22 

15
Figure 1:
1 A screenshott of the jCreattor developmen
nt environmen
nt working on W
Windows

Figure 2:
2 A screenshoot of the Eclipse developmentt environment working on M
Mac OS X

16
 Figure 3: Potential word inputs to be updated after inserting a new word on the gameboard

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14

4 R

5 E

6 A

7 C A N C E L

8 Q

9 A C U T E

10 I
11 R

12 M E R G E

13

14

Figure 4: A sample user-application interaction

* * * Start of Konrad's turn.

Your rack: [e, t, f, g, n, r, i]

check ring wahtever

1. ring - valid
2. wahtever - invalid

insert 7 7 h ring

[........................]

You scored 8 point(s).

finish turn

Your rack after drawing new tiles: [e, t, f, g, j, p, e]

* * * End of Konrad's turn. (70 s)

Konrad: 8
Another Player: 0

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
0 # . . - . . . # . . . - . . #
1 . ~ . . . = . . . = . . . ~ .
2 . . ~ . . . - . - . . . ~ . .
3 - . . ~ . . . - . . . ~ . . -
4 . . . . ~ . . . . . ~ . . . .
5 . = . . . = . . . = . . . = .
6 . . - . . . - . - . . . - . .
7 # . . - . . . r i n g - . . #
8 . . - . . . - . - . . . - . .
9 . = . . . = . . . = . . . = .
10 . . . . ~ . . . . . ~ . . . .
11 - . . ~ . . . - . . . ~ . . -
12 . . ~ . . . - . - . . . ~ . .
13 . ~ . . . = . . . = . . . ~ .
14 # . . - . . . # . . . - . . #

17
 Figure 5: A list of commands available in the program

insert X Y h/v WORD insert a sequence of tiles (X - the row of the first
tile, Y - the column of the first tile, h/v describes
the direction of the word, WORD - the uncapitalised
word you want to insert, capitalise letters you want
your blank tiles to cover), e.g.:
insert 7 5 H libeRty
finish turn finish your current turn (if you haven't made any input
- it means you give up as for now)
finish game instantly finish the game and present results based on
current points

- double letter value

= triple letter value
~ double word value
# triple word value

check WORD1 WORD2... check if the provided words are in the dictionary
check REG_EXP return all valid words that satisfy the regexp, e.g.:
check [degw][alqr]...[aeghrx]

show rack show your rack

show gameboard show the gameboard
show results show the results of all players
help show this help

set premium on turn showing premium tiles on

set premium off turn showing premium tiles off

Figure 6: The BSD License

Copyright (c) <YEAR>, <OWNER>

All rights reserved.

Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
Redistributions of source code must retain the above copyright notice, this list of
conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list
of conditions and the following disclaimer in the documentation and/or other
materials provided with the distribution.
Neither the name of the <ORGANIZATION> nor the names of its contributors may be
used to endorse or promote products derived from this software without specific
prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.

18
 Figure 7: GNU General Public License summary from Creative Commons

The GNU General Public License is a Free Software license. Like any Free Software
license, it grants to you the four following freedoms:

1. The freedom to run the program for any purpose.

2. The freedom to study how the program works and adapt it to your needs.
3. The freedom to redistribute copies so you can help your neighbour.
4. The freedom to improve the program and release your improvements to the
public, so that the whole community benefits.

You may exercise the freedoms specified here provided that you comply with the
express conditions of this license. The principal conditions are:

You must conspicuously and appropriately publish on each copy distributed an

appropriate copyright notice and disclaimer of warranty and keep intact all the
notices that refer to this License and to the absence of any warranty; and give any
other recipients of the Program a copy of the GNU General Public License along with
the Program. Any translation of the GNU General Public License must be accompanied
by the GNU General Public License.

If you modify your copy or copies of the program or any portion of it, or
develop a program based upon it, you may distribute the resulting work provided you
do so under the GNU General Public License. Any translation of the GNU General
Public License must be accompanied by the GNU General Public License.

If you copy or distribute the program, you must accompany it with the
complete corresponding machine-readable source code or with a written offer, valid
for at least three years, to furnish the complete corresponding machine-readable
source code.

Any of the above conditions can be waived if you get permission from the copyright
holder.

Your fair dealing and other rights are in no way affected by the above.

Figure 8: The MIT License

Copyright (c) <year> <copyright holders>

Permission is hereby granted, free of charge, to any person obtaining a copy of

this software and associated documentation files (the "Software"), to deal in the
Software without restriction, including without limitation the rights to use, copy,
modify, merge, publish, distribute, sublicense, and/or sell copies of the Software,
and to permit persons to whom the Software is furnished to do so, subject to the
following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

19
Figure 9: A screenshot of the application's website – jscrabble.kundziad.net

20
Figure 10: A screenshot of a sample huma
an player turn
n on Mac OS X

21
Figure 11: A screenshot of one gamee’s results on Mac OS X

22