With the sort of hardware I've described, it's easy to manipulate numbers. Consequently, computer scientists rapidly worked out how to implement high-level languages whose only concern was numbers, vectors, matrices, etc. It's harder to see how you would implement more ``symbolic'' programs such as a word processor or even a production system.
So in the early days of AI, the programmer had to work out how to encode every item of data - be it a sentence, or a chess-board, or a logical statement - as numbers, and every program as a program that operated on numbers. For example, a hypothetical chess program:
integer From, To; integer array Board [ 1:64 ]; if Board[From] = 1 and Board[To] /= 0 and ( To=From+7 or To=From+9 ) then Board[To] := 1; Board[from] := 0;The board is represented as a 1-d array of locations 1 through 64. The piece that's just moved is at location
From. Each position
Pon the board is associated with a number
Board[P]representing what's there. It's 0 if the position is empty; 1 for a paawn; 2 for a bishop; etc.
The task of this program fragment is to work out whether the piece being
moved is jumping onto an occupied square, and if so whether it can
capture anything. The location of the target position is
the program fragment means ``if the piece being moved (at
From) is a pawn (
1), and the target position
Board[To]) is not empty (
\= 0), and it's diagonally ahead
of the piece, then move the pawn to the target, and empty the square it
was on''. In practice, you'd need to record the capture as well.
Manipulating this kind of encoding is tedious and error-prone. So later languages took over more of the burden:
if CurrentMove.Piece = pawn and IsOccupied( CurrentMove.To ) and CurrentMove.Direction = diagonal then Board[CurrentMove.From] := empty; Board[CurrentMove.To] := CurrentMove.Piece;