The main ideas behind a chess engine can be easily understood. The Maple worksheet
in Every Chess Configuration produces a unique encoding
for each board configuration BC, which will be a number in {0,...,t-1}. This number is
then passed to the Move Generator, which generates all legal configurations that
result from BC. Each such configuration is then passed to the Evaluation Function,
which generates a real positional value PV, based on a specific list of
criteria. The next best move will be the configuration which maximizes PV. Using
explicit steps:

Construct a list of criteria, giving points for each positional or tactical
advantage on a specific configuration.

Start with any legal configuration: BCÎ{0,1,2,...,t-1}

Let K be the set {1,2,3,...,k}, with k being the cardinality of all legal
configurations which result from BC in one move

Pass configuration BC to Move Generator, to generate all legal configurations one
move forward: {BC(i): iÎK}

Pass generated configurations to Evaluation Function recursively (steps 4/5), to
generate positional values based on 1: {PV(BC(i)): iÎK}

Next "best" move will be BC(m): PV(BC(m))=max_{iÎK}{PV(BC(i)): iÎK}

The above list is fairly easy to understand, but quite hard to implement. There are
several reasons:

First, it is obvious that the list of criteria should be as long and as detailed as
possible, to avoid missing good moves.

Second, it's also fairly obvious that the recursion for steps 4/5 will be extremely
time consuming, because the program has to generate all legal configurations n moves
forward. Obviously, n has to be a function of some time constraint, otherwise the size
of the table of generated moves will eventually grow beyond any reasonable memory bound
in a few moves. The variation in quality between chess programs occurs because of
differences in steps 1/4/5.