Self-Learning Program
A self-learning program is software that improves its own competence from experience it generates or collects itself, rather than from a fixed rule set, and the clearest example is a game-playing program that gets better by playing against itself. The notion is older than the label: it appears in Arthur Samuel's checkers programs of the 1950s, matured in Gerald Tesauro's backgammon program TD-Gammon in the early 1990s, and reached its most dramatic form in the AlphaGo Zero and AlphaZero systems of 2017.
The defining mechanism is the self-play loop: the program plays games against a copy of itself, observes who won, uses the outcome (and often the intermediate predictions) to adjust its evaluation or policy, and then plays again with the improved version. Nothing in the loop requires a human opponent or a database of expert games; it requires only the rules of the game, a way to detect winning and losing, and a learning rule that assigns credit to the many moves that led to a result. The credit assignment problem is what makes the idea hard: a game of sixty moves ends in one bit of information, win or lose, and the program must work out which of its decisions deserve the blame or the praise. Samuel's answer, in his 1959 paper, was to use his program's deeper lookahead as a teacher for its shallower evaluations, and the general technique is known today as bootstrapping.
TD-Gammon, developed by Gerald Tesauro at IBM and reported in papers in 1992 and 1995, demonstrated the idea at near-expert strength using a small neural network trained by temporal-difference learning, a method formalized by Richard Sutton in 1988. The network took a description of a backgammon position and predicted the probability of winning; after each move, its prediction was nudged toward the prediction made at the next position, and at the end of the game toward the actual result. Starting from random weights and with no expert knowledge in the version often called TD-Gammon 0.0, it learned by playing against itself and reached strong intermediate play, and later versions with extra hand-designed features and deeper search reached a level comparable with the best human players. Backgammon helped, because its dice make play stochastic and thus explore a wide range of positions naturally, a point researchers later offered as a reason the same recipe did not immediately carry over to chess or Go.
The 2017 systems from DeepMind scaled the loop dramatically: AlphaGo Zero (Silver and colleagues, Nature, 2017) learned Go from the rules alone, without the human game records used by the earlier AlphaGo, and AlphaZero generalized the recipe to chess and shogi. Each combined a deep neural network, which proposed moves and estimated the outcome, with Monte Carlo tree search, which used those estimates to look ahead; the search results in turn became training targets for the network. This is the same bootstrapping idea as Samuel's, with a vastly richer function approximator and computing budget. The broader field is called reinforcement learning, and its textbook treatment is Sutton and Barto's Reinforcement Learning: An Introduction.
The term invites misconceptions, chief among them that a self-learning program teaches itself from nothing or understands what it does. The designers still supply the rules or a simulator, the reward definition, the network architecture, the search procedure and the training schedule, and huge amounts of computation do the rest. The approach also has real failure modes: self-play can drift into narrow strategies that exploit its own weaknesses while remaining beatable by differently styled opponents, learning can cycle in games with intransitive strategies, and it works best where a cheap, faithful simulator exists, which is why the same success is much harder in messy real-world settings like medicine or driving. Related modern techniques, such as self-play for training language-model agents or for generating training data, borrow the loop with the same caveats.
Read self-learning program as software that manufactures its own teacher: every generation of itself provides the opponents, data and feedback for the next, with humans setting only the rules of the game and the scoreboard.