Genetic Algorithms are population-based search and optimisation methods inspired by the mechanisms of biological evolution. They maintain a collection of candidate solutions, commonly called a population, and repeatedly evaluate those candidates according to a fitness function. Better-performing candidates are preferentially used to produce subsequent candidates through operations such as selection, recombination, and mutation. The process is intended to explore a large search space while progressively concentrating computational effort on regions containing promising solutions.
A candidate solution is usually represented using an encoding appropriate to the problem, historically often a binary string but also frequently a sequence, vector, permutation, tree, or other structure. Genetic Algorithms are therefore not literal simulations of biological evolution; they are computational optimisation techniques that borrow selected evolutionary principles. Their effectiveness depends heavily on representation, fitness formulation, population diversity, variation operators, and stopping criteria.
A typical Genetic Algorithm begins by generating an initial population, either randomly or using domain-specific construction methods. Each individual is evaluated by a fitness function that quantifies how desirable its corresponding solution is. Selection then determines which individuals receive greater opportunity to contribute genetic material to the next generation. Recombination combines portions of selected parent representations, while mutation introduces relatively small random changes.
Replacement determines which individuals survive into the next population, and elitism may preserve particularly strong solutions so that they cannot disappear through stochastic variation. The process continues until a stopping condition is reached, such as a maximum number of generations, a computational budget, an acceptable fitness threshold, or a lack of meaningful improvement. The algorithm therefore repeatedly alternates between evaluating candidate quality and generating new candidate solutions through controlled variation and selection.
Representation is one of the most important design decisions in a Genetic Algorithm because the operations applied to an encoded individual must produce meaningful candidate solutions. A binary encoding can be suitable for certain parameter-selection problems, but it may be inappropriate for problems where candidates are naturally permutations, continuous vectors, schedules, graphs, or structured objects. Recombination operators must also respect problem constraints where possible.
For example, directly exchanging sections of two permutations can create duplicate or missing elements, requiring specialised operators or repair procedures. Mutation similarly needs to be designed so that small changes have useful interpretations in the underlying problem. Poor representation can make a theoretically sound evolutionary process ineffective because the search operators repeatedly generate invalid or low-quality structures. Good representations can instead embed useful domain structure and make variation operators naturally produce feasible or nearly feasible solutions.
The fitness function determines what the Genetic Algorithm is encouraged to discover. It must translate the problem's objective into a measure that allows candidate solutions to be compared. In some applications the fitness function directly corresponds to the objective; in others, constraints and multiple objectives require penalties, repair mechanisms, ranking methods, or more sophisticated evaluation procedures.
Poorly designed fitness functions can produce unintended behaviour, such as rewarding candidates that exploit a weakness in the scoring mechanism rather than solving the intended problem. Fitness scaling can also influence selection pressure: if a few individuals dominate the population too strongly, diversity may disappear prematurely, whereas excessively weak selection may cause the search to progress slowly. Multi-objective applications introduce additional considerations because several conflicting criteria may need to be maintained rather than collapsed into one arbitrary numerical score.
Selection, recombination, and mutation establish the balance between exploiting promising solutions and exploring alternative regions of the search space. Strong selection favours high-fitness individuals and can accelerate improvement but may reduce diversity. Mutation provides new variation and can help recover diversity, although excessive mutation may disrupt useful structures. Recombination can combine useful characteristics from different individuals, but its benefit depends on whether the representation allows meaningful pieces of solutions to be combined.
Population size also affects this balance: small populations can be computationally cheap but vulnerable to loss of diversity, while large populations provide more variation at the cost of additional fitness evaluations. The balance is not universal; appropriate parameter settings depend on the problem, representation, evaluation cost, and landscape of candidate solutions.
Genetic Algorithms are applied to engineering design, parameter optimisation, scheduling, routing, configuration, feature selection, game strategies, and other problems where the search space is large, irregular, discontinuous, or difficult to model analytically. They are especially attractive when a candidate can be evaluated relatively easily but deriving a direct method for constructing the optimum is difficult. They can also operate when the objective function is a black box and gradients or other local information are unavailable.
Nevertheless, they do not guarantee that the globally optimal solution will be found within a finite computational budget. Their performance is often sensitive to the fitness function and parameter choices, and repeated runs can produce different results. They may also require many candidate evaluations, making them unsuitable when each evaluation involves an expensive simulation or physical experiment unless evaluation efficiency or surrogate modelling can compensate for that cost.
Genetic Algorithms have several limitations that distinguish them from exact optimisation procedures. They generally provide no universal guarantee that the best solution will be discovered, and convergence to a particular solution does not establish global optimality. Premature convergence can occur when the population becomes too homogeneous, causing the search to concentrate around a suboptimal region. Conversely, excessive diversity or mutation can prevent useful structures from being retained.
Fitness evaluations may dominate total computational cost, especially when each candidate requires a complex simulation. Constraint handling can also be difficult because variation operators may generate invalid solutions. Reproducibility requires attention to random seeds, implementation details, and stochastic configuration. These limitations mean that Genetic Algorithms are normally evaluated through repeated experiments, benchmarking, sensitivity analysis, and comparison with appropriate alternative methods rather than by assuming that evolutionary terminology itself provides a quality guarantee.
Genetic Algorithms are best understood as a particular class of evolutionary search method in which candidate solutions are represented as individuals and modified through mechanisms analogous to selection and genetic variation. Their importance comes from combining global exploration with selective retention of promising solutions, allowing them to tackle optimisation landscapes where conventional direct methods may be ineffective.
Their success is highly dependent on engineering choices rather than on the evolutionary metaphor alone: representation, fitness design, selection pressure, variation operators, population management, constraint handling, and termination all materially affect results. They are therefore flexible rather than universally superior. A rigorous application treats the Genetic Algorithm as an optimisation mechanism whose behaviour must be measured against the problem's objective, computational budget, and constraints.
