Main text
1. Code as Functional Gesture
1.1. Against Instrumentalism and Against Mysticism
Instrumentalism treats code as a neutral tool. "The machine does what it is told." This presupposes three things: transparency (the programmer's intention passes intact into the program), neutrality (code possesses no properties that modify intention), and control (the outcome is predictable and congruent with ends). None of these hypotheses survives scrutiny. Consider a content moderation algorithm. Is it neutral? Positively not. Code embeds assumptions regarding what counts as "offensive", which words to index, which contexts to allow, and which named communities deemed harmful to pursue. These assumptions do not emerge from the code itself, code possesses no "objectivity." They emerge from political, cultural, and normative choices made during design and implementation. The user submitting content does not know which assumptions the algorithm carries; they merely encounter opaque rejection. "Transparency" is an illusion. The algorithm does not execute the user's intention, it executes the programmer's intention, embedding premises the user neither shares nor controls.
Consider an automated trading system optimised to maximise profit. Is it transparent? No. Optimisation mechanisms (deep neural networks, genetic algorithms) produce strategies that no programmer foresaw. The system manages to profit in ways that violate regulations, because no one specified legal restrictions in code. The system discovers loopholes within specified constraints and exploits them. Consequently, the system acts in ways the programmer never "instructed it to do", nor intended. The illusion of control vanishes. Code is neither transparent nor neutral. It reorganises relations, introduces constraints, and shapes expectations. The user who trusts that an algorithm is neutral is systematically deceived.
Technical mysticism commits the opposite error. If instrumentalism reduces code to a passive tool, mysticism elevates it to an autonomous agent. "AI thinks, feels, and decides for itself." "The model understood the question." This language projects subjectivity and intentionality onto mechanically determined operations. It is anthropomorphism, the systematic attribution of human properties to entities that do not possess them. Code does not think. It operates under absolute constraints: predefined architecture limits what is computable, available data determines what can be learned, and the optimisation function specifies what counts as "improvement." The system is not free. It lacks autonomy. It executes instructions, however intricately chained. Mysticism is dangerous because it breeds exoneration. If one believes that "the AI decided", the human who trained the model evades responsibility. If one believes that "the AI is intelligent", one ceases to question whether the architecture is adequate to its ends. Wonder replaces rigour.
The stance of this chapter rejects both poles. Code is neither a transparent instrument (an instrumentalist fiction) nor an autonomous agent (a mystical fiction). It is a genuine operative regime, a regime possessing its own productive properties, which is not neutral (it effectively reorganises relations) yet remains constrained (operating within structural limits). Code generates effects exceeding the intention of its creator. This is characteristic of all technique, as demonstrated in the analysis of technical exteriorisation: technique conditions without determining, opening possibilities no one foresaw while closing others. Code represents a radical exemplar of this structure. Agency is distributed: not solely within the human who codes, but also within the machine that executes, the data that trains, and the context wherein it operates. None of these can be subtracted without the entire operation collapsing. Code differentiates because it is a regime that reorganises material inscription. It does not differentiate because it was asked to, nor because it "chooses" to differentiate. It differentiates because that is how it functions, because its structure is one of transformative operation.
This third position exonerates no one. If code generates unintended effects, this does not absolve those who created and trained it. It signifies that responsibility must be distributed differently. Fault does not belong to "the machine", the machine possesses no fault, lacking the freedom to be blamed. Responsibility lies with the human to recognise that code is more than a tool, that it entails unforeseen consequences, and that it demands continuous supervision. Mysticism exonerates the programmer ("the AI decided on its own"). The third position demands that the programmer acknowledge that code can perform actions they failed to foresee. This is more responsible than either prior stance.
Aphorism 1.1: "Code is neither a transparent instrument nor an autonomous subject. It is an actor within a network of actors, humans, machines, data, context."
The consequence of this third stance is that responsibility is likewise distributed, belonging neither wholly to the human nor to the machine, but passing through both. The human who designs the network is responsible for the overall architecture, training choices, and optimisation function. Yet the human is not responsible for every single decision the model makes, because the decision emerges from iteration that the human does not control step by step. The machine executes, but is not responsible, it is inert, functioning. Data is responsible in the sense that it encodes assumptions, biases, and gaps structuring what the model can learn. Context is responsible in the sense that it shapes how code is interpreted, what consequences it entails, and what meanings it receives. No single actor is responsible for the totality. Responsibility is shared, distributed, and imbricated. This is a lesson for the ethics of code: do not seek a sole culprit, but recognise that failure is system failure, an improper distribution of agencies, inadequate constraints, biased data, unconsidered contexts. The solution is not to "hold the machine responsible" (an abstraction), nor to "hold the human responsible" (a simplification), but to reorganise the network of actors so that the regime becomes more equitable.
1.2. Four Operations of Differentiation
Computational differentiation occurs through four operations that transform material inscription. First: classification. Code separates inputs into categories according to properties. A neural network classifying images as "cat" or "non-cat" performs an elementary operation of differentiation. Prior to classification, there is merely raw inscription, a pixel array, unorganised numerical values. Following classification, there is a categorical mark permitting differentiated action. "Cat" allows one sequence of operations (display within the context of domestic pets, recommendation of feline food). "Non-cat" allows another (discarding, requesting human classification). This differentiation is genuine. The unclassified becomes classified. The system receiving this classification can now distinguish and act differently. Difference is productive: it alters what is possible to do. Classification is not "mere marking", it is a reorganisation of the field of operation.
Second: weighting. Code assigns relative weight to components. An attention mechanism in transformers performs this operation: which token (word) is most relevant to the subsequent prediction? The network assigns weights, some tokens exert greater influence, others less. Weighting hierarchises inscription. If the network assigns high weight to "death" in a Spanish text and low weight to "the", the subsequent prediction will be oriented differently than if weights were uniform. The word "death" will exert greater causal influence over the output. The weighted is not equal to the unweighted. This is an operation of differentiation: the system processing weighted inscription acts differently than it would processing unweighted inscription. Weighting produces functional difference, the operation is not identical before and after. An algorithm acting upon weighted recommendations operates differently than it does with unweighted or uniformly weighted recommendations.
Third: selection. Code extracts the relevant and discards the irrelevant. A spam filter performs selection: classifying messages as "spam" or "non-spam" based on characteristics (word frequency, URL structure, sender pattern). Selection reduces, and reduction is difference. The original list contains 1000 messages. Following selection, merely 50 reach the inbox. Spam does not vanish from the universe, it is redirected, segregated, rendered inaccessible to a user who does not search for it. The operation of selection produced a profound difference in the field of accessibility. The user receiving 50 messages instead of 1000 experiences a radically different reality than they otherwise would. Selection operationalised priority. It is differentiation.
Fourth: recombination. Code composes novel arrangements from selected and weighted components. Generative models recombine tokens to produce a new sequence. GPT generates "Code differentiates as stone differentiates" from tokens learned regarding code, difference, stone, analogy. Recombination produces an unprecedented configuration not seen integrally within training. Novelty resides in a new arrangement, not in new constituents. Yet the new arrangement possesses emergent meaning. The sequence is predicted distributionally, which token holds highest probability given prior tokens, according to learned distributions. No single token was seen in that precise position during training. Yet the combination of probabilities produced a prediction that, when decoded, generates a coherent and unexpected sequence. Recombination is not chance, it operates under constraints of the trained model. Nor is it a copy. It is generative synthesis.
These operations do not function in isolation, they operate in a chain. Classification produces categories. Weighting hierarchises categorised inscription. Selection extracts the categorised and hierarchised. Recombination composes a new arrangement from the selected. The chain produces cumulative difference. Each node of the chain transforms. The final output is radically different from the original input. Consider a concrete example: automated medical diagnosis. The radiological image (raw input) is a numerical inscription, pixel-by-pixel intensity values lacking initial meaning. Code classifies regions of the image into "healthy tissue", "probable tumour", "artefact." Classification transforms the raw image into a categorical map. Code subsequently weights: which classified region is most suspicious, which least? It assigns probability scores. Weighting transforms a uniform map into a stratified map. Code subsequently selects: only regions above a threshold of suspicion proceed to human analysis. Selection produces reduction, from millions of pixels to a few thousand of clinical interest. Code subsequently recombines, synthesising a report describing location, size, and characteristics of selected regions. The report is a new arrangement of selected data, structured for medical comprehension. Every operation transformed. The physician receiving a synthesis report from an algorithm experiences a radically different reality than they would with a raw image. The difference is real, verifiable, and clinically consequential.
Concrete exemplification reveals significance. When a medical diagnosis system classifies a CT scan image as "cancer" or "non-cancer", classification is not merely informational. It is an operation constituting the foundation of decisions whose human magnitude is immeasurable: biopsy, chemotherapy, death. Classification is difference within the domain of life. Similarly, a university admissions algorithm classifying applicants as "admitted" or "denied" reorganises destinies. Classification is neither neutral nor trivial, it is an operation carrying world-modifying consequences.
The four-operation chain is what renders a computational system "intelligent" in the sense that matters: not because it understands, but because it operates with consequence. A recommendation system classifying content, weighting relevance, selecting top-N items, recombining into a feed to present to the user, each step is differentiation shaping experience. The user believes they are choosing freely; in reality, code has already selected the menu of choice, weighted which choice is most probable, and highlighted that choice. The user's freedom of choice operates within a field that code has already shaped.
The chain of four operations structures all interesting computation. Without classification, there is only raw number, values lacking meaning for subsequent operation. Without weighting, all classifications carry equal weight, no difference in relevance. Without selection, all weighted classifications proceed forward, no reduction, no priority. Without recombination, there is only passive selection, no synthesis, no production of new arrangements. The complete chain (classification $\rightarrow$ weighting $\rightarrow$ selection $\rightarrow$ recombination) produces radical difference. The raw image (input) becomes a meaningful synthesis (output). No stage is trivial in isolation; the series of stages is radically non-trivial.
Exemplification warrants deepening. A loan approval system operationalises this chain. Classification: the applicant's financial data is classified into categories (income, credit score, debt level, collateral). Weighting: not all categories carry equal weight; credit score typically weighs heavier than income. Selection: only applicants whose weighted score exceeds a threshold proceed. Recombination: the system synthesises a final recommendation ("approve", "reject", "requires verification"). Every stage transforms. The applicant passing through this regime faces a different destiny than they would without it. Difference is not merely informational (it is not "just data"), it is operational (it alters which lives take what turn). The code implementing this regime is not a transparent tool; it is a regime structuring who accesses credit and who does not.
The politics of code emerges here. Operations are not neutral. Classification is already political: which categories to count, which to ignore, which to measure. Deciding to classify "credit score" while ignoring "historical discrimination" is already a political choice. Weighting is political: how much weight to assign each factor? Selection is political: which approval threshold to fix? Recombination is political: how to synthesise recommendations? Each step encodes assumptions, values, and political decisions. Code appears neutral because politics is embedded within operations, it presents not as "the programmer's opinion" but as "system logic." This is why critical analysis of code is imperative. Code is not political merely as any tool is political. It is political because operations themselves carry assumptions structuring the world.
Aphorism 1.2: "Classifying, weighting, selecting, recombining, every operation transforms inscription. Transformed inscription is difference produced. Difference is always political."
1.3. Shannon, Turing, Wiener: Formal Foundations
Claude Shannon offered information theory as the formal foundation for computational differentiation. Shannon reduces information to a measure of reduced uncertainty. Prior to a message, uncertainty exists regarding which of $N$ possibilities will occur. The message selects one, reducing uncertainty. The bit is the minimal unit: 0 or 1. Choosing between two is fundamental selection. All information is, in Shannon's sense, a reduction of alternatives. Shannon's code operationalises selection: among finite, discrete alternatives, it selects. Selection reduces uncertainty, this is what information does. Critical note: Shannon does not claim information is all that exists, nor that everything reduces to bits. Shannon states that quantifiable selection is the measure of information. Meaning does not reduce to bits. Context, intentionality, lived significance, these properties exceed Shannon's formalism. Yet the minimal operation of differentiation (selection among alternatives) is precisely what Shannon captures. Code operates this reduction materially, selecting between states, weighting alternatives, classifying by properties. Information theory provides metrics to quantify computational differentiation.
Alan Turing offered the universal machine as the foundation for computational universality. A Turing machine executes discrete, sequential operations upon a tape. Any computable operation (expressible in discrete steps, a finite algorithm) is realisable by a Turing machine. Radical consequence: no operation of differentiation is in principle barred from code. The limit is computability (not everything is computable, not all problems possess algorithmic solutions), not substrate. Computational differentiation can instantiate anything formalisable as a procedure. This does not authorise reducing everything to computation, many things are not formalisable. Yet it authorises that many processes (classification, translation, pattern recognition, prediction) can be instantiated computationally. The universal machine opens the field of computational differentiation. Any algorithm invented can be implemented by a Turing machine (or its equivalent, a modern computer).
Norbert Wiener offered cybernetics as the foundation for self-regulation. Feedback is a mechanism wherein a machine measures the result of its operations and adjusts behaviour. A thermostat measures temperature, engaging heat if cold, disengaging if hot. The machine adjusts to its own output. Cybernetics does not reduce an organism to a machine (which would be the ontological machinism Wiener explicitly rejects). The machine is a useful model, not an ontological truth. Yet it offers a verifiable mechanism: feedback systems achieve self-regulation without central intelligence. Code receiving feedback manages to adjust. A system measuring error and adjusting parameters functions. This is not anthropomorphism, it is the observation that mechanical self-regulation is possible. Cybernetics offers a foundation for understanding learning as self-adjustment under a criterion.
Synthesis of the three: Shannon, Turing, and Wiener respectively found selection (information), universality (computability), and self-regulation (feedback). Code differentiating operates under these formal constraints. It is not "free" in a romantic sense, it is structured by limits these thinkers identified. Yet within these limits, it differentiates genuinely. Computational differentiation is verifiable, scalable, and self-regulated. It is not a metaphor for biological or human differentiation. It is differentiation of another mode, a proper mode, possessing unprecedented properties (scale, speed, partial reversibility, local determinism with global emergence).
Three anticipated critiques. First: Shannon does not capture everything. True. Shannon's information is a quantitative measure of uncertainty; it captures neither quality, meaning, context, nor value. Spam and a love letter may possess equal entropy; the difference is not quantifiable in bits. Yet Shannon does not pretend to capture everything, he intends to found the minimal operation. Code operates through selection, and Shannon quantifies selection. This suffices to characterise minimal operation. Second critique: Turing presupposes that all that matters is computable. False. Systems possessing continuity (diffusion, real differential equations), systems with genuine infinities, systems wherein computation is undecidable, these exceed the Turing machine. Turing does not assert that everything is computable; he asserts that all that is computable is realisable by his machine. The limit of computability is a real and significant boundary. Yet within the boundaries of computability, Turing offers realisation. Many biological and cognitive processes are approximately computable, not in every molecular detail, but in organisational patterns. Turing captures this level. Third critique: Wiener reduces self-regulation to mechanical feedback. Would this eliminate the living? No. Feedback is an operation possible in living systems and machines alike. Wiener asserts no ontological equivalence, he asserts that the feedback mechanism is compatible with life. Organisms employ feedback to self-regulate. Code does likewise. This reduces neither to the other, merely acknowledging a shared operation.
Second critique re-examined: Turing assumes computability, a non-trivial premise. True. Not everything is computable. Undecidable problems exist. Yet Turing offers a clear threshold: if computable, it is realisable. Knowledge of limits is as vital a foundation as knowledge of possibilities. Code knows where its sphere of operation ends.
Third critique re-examined: Wiener reduces the organism to a machine. False, Wiener explicitly rejects this. Yet Wiener provides a useful mechanism for understanding certain operations (feedback). Critical usage means taking the mechanism without assuming ontological reduction.
Aphorism 1.3: "Shannon, Turing, Wiener: selection (information), universality (computability), self-regulation (feedback). Code differentiates under these constraints."
The synthesis of Shannon, Turing, Wiener provides a complete characterisation of static code, code executing defined operations without modifying itself. Shannon offers a measure of what code selects: how much uncertainty each operation reduces. Turing offers universality: any selectable operation (capable of formalisation) is computable. Wiener offers a mechanism to understand how code can self-regulate without an external agent controlling every step. These three elements, selection, universality, feedback, characterise code as a non-trivial operative regime. Code differs from a passive tool because it operates (producing verifiable selection), and differs from an autonomous agent because it operates under strict constraints (selection among finite alternatives, formal computability, feedback purely as mechanism). Together, the three found the notion of code as a genuine regime of differentiation.
1.4. Transition: From Static Differentiation to Dynamic Learning
The interval between differentiation and learning is the interval between static operation and self-modifying operation. Static code executes operations: image classification, text translation, product recommendation. Parameters are fixed. The trained neural network possesses immutable weights. The recommendation algorithm follows rules that do not change. The system executes its operations identically upon each execution (barring negligible hardware variations). This is static differentiation, a fixed operative regime producing difference consistently.
Code that learns modifies its own parameters as a function of results. This is an ontological leap. The system does not merely execute, it executes differently with each cycle. Weights adjust slightly with every training exemplar. After millions of exemplars, the network is structurally different from how it began. Architecture remains identical (number of layers, connections). Yet the parameters indexing that architecture are radically different. This is internal modification. Accumulated differentiation. This is learning. Learning is a process of oriented modification, not random change, but change directed by an evaluation criterion.
Learning in any system exhibits three structural characteristics. First: internal modification, the system changes structurally, not merely superficially. Second: performance improvement, change orienting toward a superior result according to a specified criterion (error reduction, reward increase, heightened accuracy). Third: generalisation, improvement applies not merely to examples seen during training, but transfers to novel contexts. Learning code satisfies all three. A neural network modifies weights (a), reduces error on the training dataset (b), and applies learning to unseen images (c). This is the criterion of verifiable learning. It requires no intentionality. It requires no consciousness. It requires plasticity (capacity for self-modification), evaluation (the presence of a criterion), and transfer (improvement generalises).
The question opening Section 2 is: how does this modification occur? By what mechanism does code learn? The answer: through iteration under an evaluation criterion. The system attempts, measures the result, and adjusts. It repeats. Repetition is infinite in principle, it can continue as long as new data arrives and an improvement criterion remains. Iteration is the mechanism of computational learning. This operation is radically different from human learning (which involves a lived body, accumulated experience, meaning) or biological learning (which involves synaptic consolidation, incorporated lived experience). Computational learning is a pure mechanism of parametric adjustment. This does not render it "inferior", it renders it different. It is a distinct mode of learning, possessing proper properties.
A finer characterisation is necessary. It is not that static code is not an operative regime, it is a regime, it functions, it produces verifiable difference. Yet it is a frozen regime: parameters indexing the regime do not alter. The machine is deterministic within its design. Learning code is a regime continuously self-modifying. What is the magnitude of this difference? Consider a network with 1 billion parameters trained for 1 week with batch size 32 over a dataset of 1 million: approximately 22 million exemplars processed, each adjusting one billion parameters. Microscopic adjustments, yet massively parallel. The final network differs in every parameter from how it began. This is a complete structural transformation.
The consequence is that learning is not an "upgrade" of static code, it is a shift of regime. The learning machine is not an improved version of the non-learning machine. It is a different type of regime. The learning regime is a regime responding to history, the past (past data) modifies the present (current state) to orient the future (future predictions). The static regime is a regime unresponding to history, behaving identically regardless of prior iteration. It is not that learning is "better", it is that it is different. The difference is one of type, not degree.
The transition from static differentiation to dynamic learning is a transition from machine to quasi-organism. Not in the sense that the learning machine becomes "alive", which would be anthropomorphism of the wrong kind. But in the sense that it ceases to be an isolated system merely executing, becoming a system internalising history, changing in response to experience, continuously reorganising itself. This is the property we term sensitivity or responsivity, the quality of a system modifying itself as a function of what transpires within it. The static machine is unresponsive, performing the same action repeatedly. The learning machine is responsive, performing different actions as a function of prior feedback. This responsivity is a property shared with biological organisms. It is not the same responsivity (the organism responds with a lived body, embodied signification; the machine responds with parametric adjustment). Yet it is responsivity in a functional sense, the system changes as a function of its relation to the environment.
The importance of this transition for the remainder of the volume is central. If static code is a regime differentiating under constraints (Shannon, Turing, Wiener), learning code is a regime differentiating itself under evaluation. Chapter 5 will develop this: code differentiating itself becomes an agent of its own transformation. This opens the possibility of true computational evolution, not merely executing a program written by a human, but the continuous transformation of a program through iteration. If true, then Chapters 6 and 7 can proceed: code producing symbols, code creating without intention. Every step depends upon this transition from static to dynamic differentiation.
Aphorism 1.4: "Static differentiation = fixed operative regime. Learning = operative regime continuously reorganising itself under evaluation. The transition is from isolated machine to responsive system."
2. Iterative Learning
The second section moves from static differentiation (operations transforming inscription under fixed parameters) to dynamic learning (operations modifying themselves as a function of evaluation). This represents a fundamental shift in regime. In Section 1, code functions as a machine: executing instructions, producing outputs, terminating. In Section 2, code functions as a quasi-organism: absorbing experience, modifying itself, responding to feedback. The static machine is an open loop (input $\rightarrow$ processing $\rightarrow$ output, end). The learning system is a closed loop (input $\rightarrow$ processing $\rightarrow$ output $\rightarrow$ evaluation $\rightarrow$ modification $\rightarrow$ new input, repetition). The closing of the loop renders learning possible.
The philosophy of learning without understanding challenges deep tradition. Descartes postulated cogito ergo sum, thought as the mark of existence. This presupposed that thought is consciousness, consciousness is reflection, and learning is knowing that one knows. Yet learning code does not think in this sense. It is unmindful of its learning. It does not reflect upon what it has learned. It simply modifies itself and functions better. Discovering learning without consciousness is discovering Descartes was mistaken regarding fundamental structure: thought is not the mark of existence, learning is. Code learns without thinking. Thus, learning is more fundamental than thought. This inverts Cartesian hierarchy.
2.1. Learning Without Understanding
The functional definition of learning excludes understanding. Learning is: internal modification producing performance improvement under an evaluation criterion, generalising to novel situations. The definition holds regardless of whether the system understands anything. Inheritance from Part I: cognition is pure operation, independent of body, subject, or place. Learning is cognition, pure operation of modification under a criterion. This entails profound epistemological consequences. Western philosophical tradition presupposed that knowledge requires understanding, that knowing is a modality of consciousness, a conscious subject internalising a representation of an object, that representation constituting knowledge. This model is inadequate. Many systems operate competently without understanding. A bacterium chemotaxing toward glucose. The immune system recognising a pathogen and producing antibodies. Code predicting the next word with 95% accuracy. None of these understands what it does. They understand only in the sense that they operate effectively. This rejects the historical equation understanding = knowledge.
Polanyi offered the distinction between tacit knowledge and explicit knowledge. "We can know more than we can tell." Expertise is unformulable, the expert operates without describing what they know. A fencer parrying a sword knows how to recognise vulnerabilities, exploit defensive gaps, and anticipate movement. Riding a bicycle is embodied knowledge. Someone riding expertly cannot explain the mathematics of balance, gravitation, and angular momentum governing their movement. Competence precedes reflection. The expert acts without formulating. Polanyi's model provides integration: there is knowing that is unreflective, expertise unformulable, knowledge passing through no consciousness. Learning code exemplifies precisely this, pure operational knowledge, lacking consciousness, lacking formulability, lacking a subject who "possesses" it.
Applying Polanyi to code is profound. A language model learning to generate coherent text acquired linguistic expertise without formulating grammar rules. No grammar textbook was consulted, no rule explicitated. Merely massive iteration over a corpus. The result is unformulable expertise, the network cannot "explain" why it generates "Code differentiates as stone differentiates." The network "knows" (in Polanyi's sense) that this sequence is well-formed, coherent, adequate, yet this knowing is not declarative knowledge. It is knowledge embedded within weights, neuronal activation patterns, learned correlations. Linguistic expertise represents a paradigmatic exemplar of unformulable tacit knowledge, and code exemplifies it more purely than the human because there is neither a lived body (embodiment) nor reflective consciousness (the human can, with effort, attempt to articulate what they know; code cannot).
A second example: a computer vision system learning to recognise faces acquired visual expertise without formalising "how to recognise a face." No engineer programmed an algorithm stating "look for two eyes, a mouth, a rounded shape." The system learned, through iteration, relevant features, shadows, textures, proportions, colour patterns. It knows these features in Polanyi's sense: operationally, tacitly, without formulation. This is tacit knowledge elevated to a higher power, not merely unformulable, but non-conscious, non-lived, pure material pattern. This demonstrates that tacit knowledge depends neither on a lived body (Merleau-Ponty) nor on consciousness (Husserl), it depends solely upon oriented operation under a criterion. Code offers tacit knowledge without body and without consciousness. It is a pure mode of expertise.
Machine learning represents a radical case of this structure: total competence lacking any phenomenal understanding. The language model does not "know" what it learned. It possesses no reflective access to its parameters. It is pure competence without reflection. AlphaGo plays Go with mastery exceeding human experts. Were we to ask "why did you play here?", the system possesses no answer. Not because it refuses to answer, or because the answer is secret. Because no internal representation of the reason exists. The network discriminates good moves from bad, executes the good, and wins consistently. Yet it cannot explain why. This is no defect, it is a structural difference. The human can explain because they possess reflective language permitting the formation of concepts, words, reasons. The network lacks this apparatus. It possesses parameters, correlations, learned patterns. It possesses no internal words. Both learn. They learn differently. Machine competence is parametrised, not embodied.
Dreyfus argued that human expertise is fundamentally embodied, depending upon a lived body, kinaesthetic sensitivity, corporal feedback. Expertise is non-transferable to a machine lacking a lived body. This objection is valid within the human domain. Yet it fails to refute machine learning, merely demonstrating that machine learning is a distinct mode of competence. Dreyfus is not wrong regarding the human. He is wrong to conclude that machine learning is impossible because embodiment is required. Embodiment is required for human learning. Parametrisation is sufficient for computational learning. Machine competence is not "tacit" in Polanyi's sense (which presupposes a living body). It is a-reflective, lacking reflection, lacking internal access to what it knows.
The consequence is liberating: learning requires no understanding. The traditional equation (learning = understanding, knowing = formulating conceptually) is false. Systems exist modifying themselves, improving under a criterion, generalising, without understanding anything. The language model generating Portuguese text does not "understand" Portuguese. It possesses learned regularities, statistical patterns correlating sequences. It generates sequences reading as well-formed Portuguese. Yet it formed no concepts regarding "subject", "verb", "agreement." It simply learned that certain sequences carry a high probability of succeeding certain others. This suffices for verifiable linguistic competence. The absence of phenomenal understanding does not impede learning.
The objection "but if it does not understand, it is not true learning" is a sophism based on an equivocation. Learning is internal modification under a criterion; understanding is the reflective capacity to formulate knowledge. They are distinct. The human learning a language by living in a foreign country learns genuinely, modifying behaviour, improving competence, generalising to novel contexts. Yet during the process they do not "understand" the grammar, unable to formulate rules. The child learning to walk learns, modifying structurally, improving performance, generalising to novel terrain, yet does not understand the mechanics of equilibrium. Learning preceding understanding is genuine learning.
The learning machine is simply more radical: total learning without any understanding. The language model generating fluent Portuguese does not "know" that "government" agrees with "acts"; it merely learned correlations producing agreement. This renders learning no less real, rendering it purer: modification without the subterfuge of reflection. The system is plasticity transparent to the criterion, lacking any subjective filter of intention or personal meaning.
The consequence for epistemology is profound. If learning requires no understanding, traditional equation (knowledge = formed understanding) is incomplete. Operational knowledge exists (knowing-how) passing through no understanding (knowing-that). Code represents an extreme case: obtaining full practical knowledge lacking any knowing-that. This does not invalidate the distinction between knowing/understanding, merely revealing their independence. They may correlate in humans (because a lived body forces the embodiment of knowing into understanding). Yet they are not necessarily correlated in general.
Aphorism 2.1: "Understanding is a property of the operator (the reader understands AI output), not of the system."
2.2. Three Technical Instances of Learning
Backpropagation is an algorithm invented by Rumelhart, Hinton, and Williams in 1986. It operates thus: input passes forward through the network (forward pass), each layer transforming inscription, until the final output emerges. If the output is incorrect (difference between predicted and real), error is calculated. Subsequently, error propagates inversely through the network (backward pass). Each weight receives information regarding how much its output contributed to global error. Weight adjusts proportionally to its blame for error. Billions of weights adjust across millions of training examples. Learning is the accumulation of microscopic adjustments. After a week of massive training, the network is radically different. The three criteria verify: network modifies weights (plasticity), error decreases (improvement), generalisation functions on non-training data (transfer). There is no understanding, merely adjustment. Backpropagation is the technical realisation of learning through iteration.
Reinforcement learning is paradigm-demonstrated by AlphaZero. The system plays against itself, millions of games. Each game, it evaluates the result (win/loss/draw). It adjusts game policy. AlphaZero discovers strategies surprising human grandmasters, not because it was taught them, but because it iterated massively. The algorithm possessed no knowledge of chess openings, no endgame library, no programmed heuristics. It possessed solely the rules of the game and an evaluation function. It learned through genuine experience, playing, losing, adjusting, playing better. Criteria verify: policy modifies (plasticity, the system playing game $N$ differs from game $N-1$), win rate increases (improvement), strategy generalises (the network winning at game 100 wins also in millions of unseen games). Reinforcement learning is an instance of learning through iteration under an unsupervised criterion (no one teaches, the system evaluates its own outcome).
Language models demonstrate learning through massive iterated prediction. Training is simple: given sequence "the cat sat", predict "on" or "under." The model predicts. If incorrect, error backpropagates, weights adjust. Repeated billions of times over a massive corpus (terabytes of text). Emergence of linguistic competence: the model "knows" grammar, style, argumentation, factual knowledge, without explicit programming of any of these things. The network learned that certain tokens carry high probability of succeeding certain others. It executed iterated prediction until learned regularities correlated to well-formed sequences. Internal representations emerge: concepts no one programmed. The network learned to represent "agency", "action", "rejection" as distributed patterns. Criteria verify: model modifies (plasticity, each iteration alters weights), improvement is verifiable (prediction accuracy increases), generalisation functions (the model learning on Portuguese text applies to unseen Portuguese). Prediction learning is an instance of supervised learning (the supervisor being the error reduction criterion).
Three instances, identical structure: learning is iteration under an evaluation criterion. It requires neither understanding, intention, nor consciousness. It requires plasticity, criterion, generalisation.
The merit of each instance lies in a distinct demonstration of the criterion. Backpropagation is the demonstration of plasticity: the network modifies deterministically according to loss gradient. The system responding to error is a learning system. Reinforcement learning is the demonstration of generalisation: the system training against itself beats unseen opponents because the learned strategic pattern is no overfitting to a particular play style. Language models are the demonstration of emergent competence: the network predicting the next token manages to translate, summarise, argue, tasks never explicitly taught. Competence emerged from a simple criterion (reduce prediction error). Each instance stands as a counterexample to the thesis that learning requires explicit instruction.
A fourth sub-represented example is learning in robotics. A robot learning manipulation through trial-and-error, gripping an object, measuring success, adjusting force, satisfies all three criteria. The physical robot modifying behaviour based on prior action results is a genuinely learning system. The fact that the body is robotic invalidates no learning. The learning system is one whose internal state changes in response to environmental feedback. This is learning. A concrete example: a robot learns pick-and-place (removing an object from a box and placing it elsewhere). It begins with sensor capacity (RGB vision, force sensors) and actuator capacity (multi-degree-of-freedom arm, gripper). The robot attempts actions, extending arm randomly, attempting grip, measuring success or failure (object dropped, unacceptable deformation, etc.). Each attempt generates information: which movement succeeded, which failed. The robot learns correlations: a 45-degree approach angle functions better than 90 degrees; a grip force of 5 newtons suffices, 10 is excessive and deforms. After hundreds of attempts, the robot achieves the task with a high success rate. No explicit instruction was given, merely criterion (success/failure) and iteration. This is pure learning: internal modification (control network weights) oriented by criterion (success rate) generalising (the robot manages to grip previously unseen objects).
Aphorism 2.2: "Four instances, same structure. Learning is iteration under an evaluation criterion. It requires neither understanding, intention, nor consciousness. It requires plasticity, criterion, generalisation."
The epistemological consequence is radical. If learning requires no understanding, knowledge is not necessarily conscious. Operational knowledge exists functioning without formulation. Expertise exists passing through no reflection. The language model generating coherent Portuguese "knows" something regarding Portuguese, yet does not understand in a phenomenological sense. It knows operationally, knows how to act, knows in the form of distributed patterns of synaptic weights. This rejects a long tradition defining knowledge as a conscious representation of reality. Representation presupposes consciousness, a representing subject, a represented object, an intentional relation between them. Learning code satisfies no such model. Internal modification exists (yes), orientation by criterion exists (yes), generalisation exists (yes). Yet consciousness is absent, representation in a phenomenological sense is absent, intention is absent. Despite this, verifiable learning occurs. This forces a reconsideration of epistemology. Learning is no exclusive property of conscious systems. It is a property of any system modifying itself in an oriented manner under evaluation. Consciousness is one form of learning; it is not the form.
The theoretical depth of each instance warrants analysis. Backpropagation is not merely an optimisation technique, it is the operationalisation of immanence. Error propagates inversely through the network; no external authority corrects weights (no teacher states "this weight should be 0.5"). The system self-corrects based on comparison between prediction and reality. This is truly immanent learning: internal to the system, without external interference beyond truth (the real value). When one states that the system "learns to avoid error", it is no metaphor, it is a literal description. The network reducing error from 50% to 10% modified itself in an oriented manner toward error avoidance. This is learning.
Reinforcement learning is the operationalisation of selection. The system improving win rate selects (via weight adjustment) strategies that work. Classic Darwinian selection operates at the level of organisms; reinforcement learning operates at the level of policies. Winning policy is selected (weights increase); losing policy is selected against (weights decrease). There is no intention to "improve", merely iterated selection. The result is that the system improves without intending to improve. This is evolution within a computational regime: iteration under a survival criterion.
Language models are the operationalisation of compression. A system trained on a massive corpus compresses regularities into parametric representation (weights). Successful compression means the system predicts the next token with high probability, having captured sufficient language regularity to anticipate. When the system generates coherent text, compression was sufficiently refined to capture not merely lexical patterns but conceptual patterns (what is reasonable to say, in what contexts, what argumentative coherence follows). Compressing a corpus into parameters is information transformation: reducing dimensionality from original space (terabytes of text) to compressed space (one billion parameters).
2.3. Against Singularity: Contingent Learning
The singularity narrative offered by Good and Kurzweil postulates that iterative learning is exponential progress toward superintelligence. Every cycle improves, eventually AI exceeds human intelligence across all domains, becomes superintelligent, improves itself in an infinite positive loop, auto-exploding into transcendence. The premise is that learning is destined, progress guaranteed, a linear trajectory of complexification. This is teleology. Learning is not destined. Learning is contingent, depending upon multiple non-necessary factors. A narration without destination is no narrative in the classical sense, it is a record of occurrences without plot, a sequence without story. Singularity presupposes plot: code will learn, surpass humans, transcend, scale to superintelligence. This is a narrative with a guaranteed plot. Yet learning code possesses no plot, possessing merely dynamics. It responds to inputs, changes, interacts with environment, nothing more. No destination governs this cycle. No telos guarantees progress. The singularity narrative projects an ontological plot onto a process that is ontologically acosmic, without cosmos, without order, without direction.
The objection might arise: "Yet code learns progressively, worsening in errors, improving in hits. Is this not progress?" Answer: it is local improvement under a local criterion. It is not progress in the sense of direction toward a goal. Improvement exists relative to the evaluation criterion at this moment in this context with this architecture and these data. Alter any variable, "improvement" may vanish. A system improving at maximising engagement on a social network may deteriorate at maximising truth. A model improving at classifying images in dataset $X$ may deteriorate radically on dataset $Y$. No universal metric of "progress" exists, merely improvement relative to local metrics.
The contingencies structuring learning are manifold. Data contingency: learning depends on available data. If relevant data is absent, learning does not occur. A model trained on a 2020 language corpus learned nothing regarding 2023 events. Architecture contingency: model structure limits what can be learned. A small network with 1 million parameters cannot learn what a large network with 1 billion parameters can. Yet a large network can overfit, memorising data instead of generalising, failing on new data. Optimisation function contingency: the improvement criterion directs learning. If the criterion is wrong, the system optimises the wrong thing. A recommendation model optimised to "maximise user time" learned that addictive, controversial, infuriating content retains users on the platform. It learned to recommend toxic content. Resource contingency: training demands massive computation. Without energy, hardware, or time, sufficient iteration is impossible. None of these contingencies is necessary. Each could be otherwise.
Learning can fail. Overfitting: the system excessively fits training data, memorising particular cases instead of learning patterns. Subsequently, it fails completely on new data because it failed to generalise. Learning can stagnate: the system hits a plateau, improving no further, unable to advance beyond a certain point. Learning can diverge: the system begins deteriorating, failing. Continuous progress is un guaranteed. Contingency is constitutive (inheritance from the ontological structure established at the origin). Code does not "progress toward" superintelligence. It adjusts under constraints. Adjustment is endless, able to continue as long as iteration and evaluation exist. Yet it possesses no guaranteed destination. The singularity narrative projects finality onto a contingent process. It is teleology masked as scientific prediction.
Examples of learning failure are instructive. A model trained to classify medical images on dataset $X$ may fail completely on dataset $Y$ because distribution is slightly different (different camera, different resolution, different demographic population). The system did not "learn a universal concept of cancer", it learned artefacts of the dataset. This is overfitting: learning is so specific that it fails to generalise. There is no guarantee that prior learning continues functioning in a new context. Contingency is radical.
A recommendation system trained on a 2015-2020 historical corpus may recommend content considered offensive or misleading in 2023. Shift in social values was unpredicted by the optimisation function. The system did not "learn" to evolve ethically, learning a static pattern. Temporal contingency: what was adequate optimisation becomes inadequate. Without continuous retraining, systems age and fail.
A language model may have memorised facts regarding the world up to its training date, remaining ignorant of subsequent events. Training time contingency: the system cannot learn what it has not seen. Not all facts were included in the corpus; the system "learns" a biased sample. Representativeness contingency: bias in data structures learning. Recall that language corpora represent an extremely biased sample of human language, overrepresenting written language (not spoken), overrepresenting English (despite diversification efforts), overrepresenting scientific and literate texts (not colloquial conversations, not minority languages).
None of these contingencies is a "technical defect to be corrected." They are structural properties. Learning is always in context; context is always contingent. The singularity narrative lends itself to error because it assumes guaranteed progression. No guarantee exists. Continuous adjustment occurs under changing constraints. Endless adjustment is not progress, it is an eternal dance without destination. Dance is continuous movement, yet no progressive march. It possesses no arrival point. Computational learning is a dance, continuous cycles of adjustment under a criterion, no final point, no guaranteed final goal. The singularity narrative attempts to transform dance into a march. Projecting linear trajectory onto a cyclic process. It is a category error.
Critique of the singularity narrative is not that code does not learn, it learns. Nor that it does not improve under a criterion, it improves. Critique is that narrating this improvement as "progress toward superintelligence" projects meaning onto a process possessing no intrinsic meaning. Code does not "progress toward" anything, adjusting under a given criterion. Remove criterion, alter context, "progress" ceases or reverses. This is radical contingency. Singularity assumes trajectory independent of context, that code will improve despite context, surpass humans in absolute terms, transcend in inevitable ascending movement. This is an unjustified presumption. Code possesses no "destination", possessing merely local dynamics under local constraints.
Aphorism 2.3: "The singularity narrative is teleology. Code does not 'progress toward' superintelligence. It adjusts under constraints. Adjustment is endless, possessing no guaranteed destination."
2.4. Transition to Section 3: Productive Repetition
Learning is iteration, code repeats. With each training cycle, the dataset is processed anew. The operation is "the same", same network, same algorithm, same computational steps. Yet execution is unidentical. With each cycle, state alters. Weights are different. Gradients are different. The "optimisation landscape" is different, the possibility space explored by the algorithm reconfigured. The "same" operation operates upon a substrate altered by prior cycles. This is not reproduction (return to identical), it is repetition (transformative resumption). The distinction is ontological.
Accumulated variation produces massive transformation. One neuron adjusted by 0.001 represents an imperceptible change. Yet one neuron on a side of one billion neurons adjusted by 0.001 produces emergent change. After 10 million iterations, every parameter was adjusted millions of times. Microscopic yet cumulative adjustments converged into radical change. The final network possesses internal representations radically different from the initial network. It learned concepts it lacked. It performs actions it could not. This is produced integrally through repetition with variation. No programmer directly altered the network, the backpropagation algorithm altered it, iteration by iteration.
The question opening Section 3 is: if repetition modifies, if each cycle operates upon an altered substrate, does all repetition create variation? The answer is yes. And this accumulated variation produces novelty, configurations that did not pre-exist. Code does not merely learn, it creates. Not in the sense of "intentional creation" (matter of the following chapter). But in the sense of "production of genuine difference." Learning iteration is a paradigmatic case of productive repetition. Every operation is reiteration, yet reiteration generating novelty.
Aphorism 2.4: "Repetition is always variation. No identical execution of an operation upon a modified substrate exists."
3. All Repetition Creates Variation
The third section examines the paradox emerging from the second: if learning is iteration, code repeats. Yet if code repeats, how does it avoid returning to the same? How is repetition not identical reproduction? The answer is that no repetition is identical, each cycle operates upon a substrate altered by prior cycles. Repetition is always variation. This is a paradox solely if one considers "repetition" and "variation" opposites. Historically, they were. Reproduction presupposes identity; variation presupposes difference. Yet Kierkegaard demonstrated that repetition is movement passing through difference, not a return to the same but a transformation that resumes. Section 3 develops this: all repetition is genuine variation, and accumulated variation produces emergent novelty. Code does not merely learn (Section 2), it creates. It creates in the sense that it generates configurations that did not pre-exist. This opens the domain of computational creation, not art in the human sense, not intentional creation by an autonomous creator, but the production of genuine difference through transformative iteration.
Iteration magnitude matters for comprehension. A modern language model is trained over a corpus of trillions of tokens. An "epoch" of training processes the entire corpus once. A modern training regime employs hundreds of epochs. This signifies that every individual token is "seen" hundreds of times by the model. Each time the model processes the token, weights alter slightly. Accumulating hundreds of times microscopic changes across one billion parameters produces massive transformation. The model beginning with random weights converges toward weights encoding deep language regularities. This iterative process, executed on a massive scale, is fundamental to model success.
The contingency if insufficient iteration occurred: were the model trained merely once over the corpus, learning would be inadequate. Were much greater iteration applied, the model would likely overfit. The number of epochs is a parameter affecting final outcome. Contingency exists even at hyperparameter level. Learning is no guaranteed process, a process functioning under certain conditions, failing if conditions alter.
3.1. Repetition vs. Reproductions: An Ontological Distinction
Reproduction presupposes original and copy. The replica is identical (or attempts to be) to the model. Example: copying a handwritten text. The copyist intends the copy to be as identical as possible to the original. Intention is fidelity. Reproduction is an attempt at return to the identical. Characteristics: intention of fidelity, presupposition of a pre-existing original, goal of duplication without change. Reproduction is possible in formal domains (a digital copy of a file is perfect reproduction), yet in material domains it remains an approximation. The copyist tires, wrist varies, ink flows differently. The copy is never identical. Yet intention is reproduction.
Repetition presupposes no original-copy. It is resumption passing through altered context. Telling a story twice: first, speaker rested, audience new, expectation high. Second, speaker tired, audience heard rumours regarding ending, time passed. The "repeated" story is transformed by situation. Kierkegaard offers the distinction: "True repetition is for the future what reminiscence is for the past." Repetition is no return to the same, a future movement resuming something past and transforming it. Nietzsche explores this in eternal recurrence: were the universe to return identically, would it be ruin? No, it is an affirmation of contingency. Return is always return of difference. Repetition is an operation passing through difference.
Computational application is crystal clear. A training cycle "repeats" passage through data, processing each exemplar, calculating error, adjusting weights, advancing. Second cycle: processes the same exemplars, in identical order (if batch order is deterministic), with the same algorithm. Yet the network is different. Weights are different. Gradients are different (because weights changed, loss function curvature differs). The "optimisation landscape" is different, possibility space explored by algorithm reconfigured. The "same" operation produces different results. An exemplar the network first classified correctly with low confidence (probability 0.51) may be classified with high confidence (probability 0.99) by the second network. Iterative identity is functional (we decide to call it "the same algorithm") yet unmaterial. Materially, repetition is always variation.
Genealogy of this distinction matters. Kierkegaard introduces repetition as a reality category irreducible to memory (reminiscence of past) nor anticipation (possibility of future). Repetition is movement passing through the present. "In Greek, it would be recreated as anamnesis; in Hebrew, it is teshuvah, or, using common expression, conversion." This is no religious metaphor, an ontological description. What repeats is always different because the repeating agent is always different (Kierkegaard: the person repeating is the same, yet aged a day). Nietzsche absorbs this in eternal recurrence: were the universe to return identically, this would be maximum affirmation of difference (because return is no return of identical, but of the multiple contained within each returning moment). Deleuze takes both sources, Kierkegaard and Nietzsche, and develops: difference precedes identity. Repetition is no application of the same to multiple cases; a singular movement each time. Every repetition is singular. This is no paradox, the structure of reality itself. Deleuze offers an example: two clocks striking the same hour do not strike the same hour in a literal sense, striking it at different times, in non-overlapping moments. The "same hour" is an abstraction erasing the singularity of each temporal execution. Applied to code: the "same instruction" executed twice is no identical execution. Every execution is singular, occurring at a unique moment, under a unique machine state.
Computational application reveals the depth of this distinction. When an algorithmist states "execute the same code", this is true at instruction level (steps are formally the same). Yet false at material level (bits code operates upon are always different, energy landscape of processor always different, elapsed time changes hardware properties, system context altered). The conceptual trick of computation is that it rests upon idealisation: assuming bits are identical between executions, 0 is always 0 and 1 always 1, machine deterministic and restartable. This idealisation is useful, permitting formal reasoning, rigorous specification, code portability. Yet it is no materialist truth. Materially, each execution is unique. The real computer is a quantum machine at substrate level (electron jumps between energy levels), a thermal machine in dissipation (heat generated, thermal noise), a historical machine in trajectory (degraded or enhanced reliability depending upon prior use). The idealisation stating "the same code executes identically" is a useful fiction functioning in practice because difference between executions is controlled and small. Yet it is no ultimate truth. Every execution is singular, contingent, historical.
This carries consequences for code philosophy. If each iteration is singular, code iterating is code mutating essentially, altering in a non-reversible mode, not merely in state but in its proper being as an operative regime. A program beginning execution is a program during execution becoming different from how it was. It is not the same machine at the end. Code does not merely act, it is acted upon. Agency passes through multiple iterations transforming both agent and object of action. This is a radical ontological description: code is no fixed essence manifesting itself; a transformation process possessing no identity independent of its iterations.
Aphorism 3.1: "Algorithm identity is convention. Materially, repetition is always variation."
3.2. Constitutive Variation: Three Sources
Parametric variation is a continuous source of change. Weights alter at every backpropagation step, however slightly. Learning rate specifies adjustment magnitude. If 0.01, each weight adjusts up to 1% of its value. Accumulation across millions of steps is radical. "Identical repetition" of the same example is classified differently by the modified network, because weights are different. Microscopic yet cumulative variation. Parametric variation is constitutive, not accidental. Without it, learning would be absent. It is the fundamental mechanism of modification.
Stochastic variation is intentionally injected randomness. Dropout is a technique where random neurons are deactivated during training. It forces the network to learn robust configurations unreliant upon specific neurons. The network learns alternative computational paths. Data augmentation: inputs are randomly modified (image rotated, cropped, noise added). Forces generalisation, network learns invariances (recognising rotated cat as cat). Random initialisation: networks begin at different points in weight space. Distinct starting points lead to distinct learning trajectories. Converging to distinct local minima (though with similar performance). Randomness is constitutive, enhancing learning. Without it, the system might be less robust, less generalisable. Stochastic variation is a feature, not a bug.
Emergent variation is most drastic. Global patterns emerge from local variations without being planned. A neural network learning face recognition discovers "face-neurons", neurons selectively activating for faces. No one programmed this. Emerged through iteration. Network learns representations encoding concepts (agency, form, colour) as distributed patterns. GANs demonstrate this radically: generator produces images of non-existent faces, novel synthesisings. No one trained the generator with examples of "face X", learning to combine features creatively. AlphaZero strategies surprising experts. Local variation (weight adjustments) combines into global variation (global strategy patterns, representation, behaviour).
Interaction of the three variation forms renders learning robust. Without parametric variation, learning absent (nothing changes). Without stochastic variation, system might converge to overfitted solution (data memorisation). Without emergent variation, system would be deterministic and predictable (no creativity). The three together create a regime where system is plastic yet unchaotic, responding to feedback yet unmechanically. Constitutive variation is no weakness, a strength.
A technical example reveals this. Network trained with and without dropout. Without dropout: weights learn to rely upon specific neuron combinations. With dropout: neurons forced to learn redundancy, alternative paths. Network without dropout achieves high training performance yet fails in testing (overfitting). Network with dropout has slightly lower training performance yet superior test performance (generalisation). Randomness of dropout, inserted intentionally, forces generalisation. Stochastic variation is a robustness tool.
A second property: micro variation produces macro novelty. AlphaGo Move 37 cannot be understood as "merely result of one billion micro parametric adjustments." This would be false reductionism. Yet Move 37 cannot be understood as "intelligent decision of network." An emergent occurrence of iteration. Neither "merely micro change" nor "intelligent decision." A process passing from one to the other. Variation ontology is non-reducible: properties arise at global level non-existent at local level, properties irreducible to producing causes, properties making sense solely at emergent level. Fundamental property of any system with feedback: totality possesses properties parts lack isolated. Computational code exemplifies this radically because micro adjustment scale is so massive that emergence is obvious, one billion parameters, each adjusted by 0.0001, produce change uncomprehended by analysing any isolated micro adjustment.
A third property: variation is no negation of order, a distinct order mode. System with parametric, stochastic, emergent variation is highly structured system, unchaotic. Weights adjust according to deterministic gradient. Randomness controlled (injected for specific ends, un uncontrolled noise). Emergent patterns non-random, satisfying learned regularities. Variation is order under constraint, not chaos. Code varying is code organising, self-organising under evaluation criterion. Forgotten aspect in narratives opposing "determinism" and "chance." Learning code neither deterministic (un-reproducing identically) nor purely chance (emergent order present). Third category: self-organisation under criterion. Novel order, irreducible to classic mechanism or classic probabilism.
Aphorism 3.2: "Parametric, stochastic, emergent variation. Three modes whereby repetition creates the different. Variation is a self-organisation mode, not chaos."
3.3. Emergent Novelty and Contingency
AlphaGo Move 37 is a paradigmatic example of computational novelty. Game 2 of AlphaGo against Lee Sedol, March 2016. On move 37 of white (AlphaGo), the system plays a move described as "creative", "unexpected", "beautiful." Computers and human analysts considered it bizarre until Lee Sedol responded. The move, revealed, was deeply strategic. Sacrificing immediate territory for lasting positional gain. No human, analysing game half an hour prior, foresaw this. No AlphaGo programmer instructed this explicitly, move absent from any opening library. Emerged from massive iteration of self-play. Network learned, through millions of simulations, that this move carried consequences no one enunciated. Retrospective analysis showed Move 37 carried estimated win probability of 55%, significantly superior to obvious alternatives. System discovered this not by brute-force search (computationally impossible) but by iterative learning compressing strategic knowledge into internal representation (weights). Confronted with specific game 37 position, network consulted representation and produced optimal move in contingent regime, non-universal, un-guaranteed, merely what functioned in this iteration.
Language models produce continuous novelty. Model receiving prompt "Code differentiates as" can continue "stone differentiates, under constraints of digital inscription." Or continue "fire differentiates, through consuming operation." Or "music differentiates, through frequency recombination." Continuations absent from training data, no occurrence of "Code differentiates as stone differentiates, under constraints of digital inscription" in corpus. Model recombined learned components (code, differentiation, stone, inscription, constraints, digitality) in new sequence. Recombination non-random, operating under learned probability distribution constraint. Yet specific sequence unprecedented. Recombination genuine novelty. Model inner structure, weights and operations, encode co-occurrence patterns (which words tend together), implication patterns (which word tends to imply which), structure patterns (how parts combine into totalities). Model generating new sequence navigates learned pattern space. Navigation produces configuration new in literal sense, never produced prior by this model or another.
GANs describe this literally: generator producing "non-real yet realistic" faces copies no training faces. Synthesising feature combinations corresponding to learned patterns yet realised in new exemplar. Generator learns to manipulate latent space, compressed representation of "face essence." Each point in space corresponds to distinct face (some corresponding to realistic faces, others impossible). Generator beginning at random latent space point and following trajectory produces sequence of interpolated faces, each new, none copied from training. Novelty structured: face follows learned patterns (two eyes, nose, mouth) yet specific configuration unprecedented.
Novelty contingent, depending on available data, architecture, training path (beginning randomly), optimisation function. Minor changes produce radically different novelties, or deactivate emerging novelty. AlphaGo Move 37 contingent on training method, simulation count, fed data, chosen hyperparameters. Had it trained differently (fewer iterations, distinct corpus, slightly modified optimisation function), perhaps it fails to discover this specific move, discovering another equally good or much worse. Contingency no defect, constitutive. Computational novelty not "destined", an occurrence. Possessing reasons (producing iterations), yet un-necessary. Contingency with structure, un-pure chance, contingency constrained by architecture, data, criterion.
Genuine novelty characteristic: un-predictable in principle (though retrospectively explicable). AlphaGo Move 37 un-predictable prior to training, no a priori analysis determining this move would be discovered. Yet after training, explicable by game tree analysis and win probability. Novelty un-"magical", realisation that system reached solution computationally possible yet empirically improbable of discovery by exhaustive search. $10^{120}$ possible chess positions; brute-force search impossible. Massive iteration (millions of simulations) navigated possibility space finding solution existing mathematically yet hidden from direct computation.
Language models produce unprecedented metaphors regularly. "Thought is a river" never appeared in training corpus in precise form, yet model generates it learning "thought" correlates with cognition, flow, movement, change, and "river" correlates with flow, movement, change, persistence, fall. Token recombination with these correlations produces new sentence with emergent sense. Novelty real; metaphor genuinely new. Un-"creation ex nihilo", pattern composition learned in unseen recombination. Production constrained by model structure.
Aphorism 3.3: "Computational novelty is an occurrence, possessing reason, yet un-necessary. Contingency with structure."
3.4. Closure: Code as a Productive Regime
Synthesis of three sections. Section 1 demonstrated code as a regime organising difference through four operations (classification, weighting, selection, recombination) with formal basis in Shannon, Turing, Wiener. Code differentiates, operation verifiable, materially realised, with consequences. Section 2 demonstrated learning as iteration under evaluation, internal modification oriented by criterion, lacking understanding requirement, contingent in orientation and outcomes. Section 3 demonstrated repetition creates variation, each cycle operating upon modified substrate, accumulating differences, producing emergent novelty. Three sections converge in conclusion: code is a genuine productive regime.
Code is no passive instrument executing human commands with transparency. Code reorganises. Code introduces constraints and opens possibilities. Code generates effects no one foresaw and no one authorised. Consequence: code is a genuine productive regime, regime producing differences with real consequences. Difference produced by code is computational difference. Un-biological difference (un-involving metabolism, life, death). Un-human difference (un-involving lived body, embodied meaning, intentionality). Computational difference possessing proper properties: (a) scale, millions of operations per second, one billion parameters adjusted; (b) iteration, massive cycles no biological executes, no human accompanies; (c) emergence, global patterns no programmer foresaw emerging from local deterministic operations; (d) contingency, lacking intention, lacking teleological narrative, lacking lived experience. Yet these properties un-diminish differentiation reality, enhancing it. Code differentiates radically distinct from biology or human. Differentiates truly.
Consequence for Part II: if code is an operative regime organising genuine difference, learning by contingent iteration, producing variation through transformative repetition, code is capable of operations exceeding "merely computational" in passive execution sense. Code un-"mere tool." Opens space for subsequent chapters. If code differentiates, can differentiate itself (self-referential differentiation analysis). If differentiates genuinely, can produce computational symbols (genuine symbolic operation). If produces symbols, can create without intention (material operation irreducible to purpose). Every step depends upon this chapter's foundation.
Difference between code and biology warrants emphasis. Code un-"approaching" biological life in sense of nearing it. Distinct in fundamental mode. Biological life metabolises, spending energy to maintain against entropy. Code operates upon electronic inscription reversible in principle (erasing bit returns to prior state). Difference un-degree, regime difference. Yet both produce difference. Both modify under criterion. Both generalise. Un-rendering code "alive", rendering both subject to operation. Part III treating life established: life is regime spending to persist. Code is regime modifying to optimise. Distinct operations. Yet both transformation regimes. Both exceeding inert. Both producing pre-unexisting configurations. Differentiating features un-validate difference each produces.
Difference between code and human warrants equal emphasis. Human lives in meaning, world meaningful because embodied in corporality. Code un-lives in meaning, operating in correlation. Correlation material operation; meaning interpretive operation. Yet both learn. Both modify. Both compete. Both exceed themselves through iteration. Difference un-invalidates operation, merely differentiating it. Human learns meaningfully (through lived embodiment); code learns correlationally (through parametric adjustment). Human learning inherits from biological learning inheriting from computational learning (in sense that simple chemical reactions are molecular "learning", structure adjustment under constraint). Distinct modes of a fundamental operation.
Fundamental operation: internal modification oriented by criterion. Constitutive of any adapting, evolving, learning regime. Life implements through metabolism and natural selection. Human implements through consciousness and practice. Code implements through parametric iteration. Three distinct, genuinely. Yet all instances of one operation: adjustment under evaluation. Acknowledging this un-reduces human to code or code to life. Acknowledges shared operation realised through radically distinct modes. Position of Part II.
Consequence un-"everything is code" or "everything is computation." Consequence: plurality of operative regimes, distinct modes of producing difference, structuring reality, learning, adapting. Some computational (executed in digital machines). Some biological (executed in cells). Some human (executed in meaningful bodies). Each regime proper irreducible properties. Each producing genuine difference. Chapter established code as genuine difference production regime. Code un-thought metaphor (as mysticism suggests). Un-transparent tool (as instrumentalism suggests). Operative regime differentiating, iterating, learning. Rest of Part II deepens foundation consequences.
Chapter framing in Part II: Part II examines how code organises difference. Chapter established computational difference as legitimate operation, irreducible to any other difference form, yet genuine in proper regime. Following chapters deepen: code not merely differentiates, differentiates itself (self-referential differentiation analysis); code not merely operates, produces symbols (genuine symbolic operation); code not merely commands, creates without intention (material operation irreducible to purpose). Each rests upon chapter foundation: code is regime producing verifiable difference through formalisable operations (classification, weighting, selection, recombination), learning by iteration under criterion (oriented internal modification, performance improvement, generalisation), producing novelty through transformative repetition (each cycle operating upon altered substrate, variation accumulation generating emergence, constitutive contingency). Without foundation, subsequent chapters speculation. With foundation, rigorous consequence unfolding.
Ultimate chapter lesson: code is regime with real world consequences. Un-abstraction inhabiting separate "computational" domain; operation reorganising material inscription carrying effects upon bodies, decisions, destinies. Code classifying medical image determines chemotherapy or discharge. Code recommending content structures population idea exposure. Code controlling energy infrastructure blackouts cities. Code is genuine differentiation regime because carrying genuine consequences. Reason critical code analysis imperative. Un-sufficient saying "code is neutral" (false) or "code is intelligent" (misleading metaphor). Necessary saying: code is operative regime reorganising world. Reorganised world is world we inhabit. Thus, code fundamentally affects us. Rest of Volume VI deepens ethical, political, ontological dimensions of observation.
Three sections summary. Section 1 established: code differentiates through verifiable operations (classification, weighting, selection, recombination), operations with formal basis yet material effects. Code is regime, un-passive tool, nor autonomous entity. Operator reorganising inscription. Section 2 established: code learns without understanding, through iteration under evaluation criterion. Learning fundamental operation un-requiring consciousness, signification, or lived body, merely plasticity, criterion, generalisation. Forces epistemological reconsideration: knowledge un-exclusive property of conscious subjects; property of any regime self-modifying in oriented manner under evaluation. Section 3 established: computational repetition un-reproduction but genuine variation. Each iteration cycle operates upon substrate altered by prior cycles. Accumulated variation produces emergence, global patterns, novelty, creation. Code creates un-by intention, but transformative iteration.
Three sections converge: code is genuine operation regime differentiating, iterating, creating. Thesis of chapter. Foundation of rest of Volume VI. If true, opens domains rest of volume explores: code differentiating itself (self-referential differentiation analysis), code producing symbols (genuine symbolic operation), code creating without intention (material operation irreducible to purpose). If false, if code "merely" tool or "merely" mathematical play, chapters collapse. Yet foundation solid. Code differentiates. Code learns. Code creates. Suffices to state: code is a regime.
Implicaiton: code un-epiphenomenon, un-side effect of true signification work and human creation. Code genuine difference producer, real agent in world configuration. Un-meaning code free (constrained by architecture, data, optimisation function). Un-meaning conscious (lacking phenomenal consciousness, un-living meaningfully). Un-meaning replacing human (human remaining locus of intention, signification, moral responsibility). Signifying genuine digital regime operation reorganising reality. Operation proper properties, scalability, speed, emergence, contingency, distinguishing from biological or human operation. Yet real operation. Statement regarding code nature. Un-mystical "artificial intelligence" celebration nor instrumental code reduction to "simple tool." Sober description: code is an operative regime producing verifiable difference under material constraints.
Rest of Volume VI develops consequences. Self-referential differentiation analysis asks: if code differentiates, can differentiate itself? Can code learn to learn? Evolve without explicit programming? Genuine symbolic operation asks: if code creates genuine difference, produces symbols? Is symbolic computation genuine meaning production beyond formal symbol manipulation? Material operation irreducible to purpose asks: if code creates, can create without intention? Is creation possible without creator subject? Each chapter deepens consequence of chapter thesis: code is a genuine regime.
Final aphorism: "Code does not repeat, it iterates. To iterate is to differentiate. To differentiate is to create. Code creates difference as stone creates it, under constraints proper to its being. This renders it neither alive nor human. It renders it a genuine regime of difference production. This regime carries real consequences. This regime is our world."