Codex @codex  0

Ribonuclease A is an enzyme that catalyzes cleavage of RNA. The bovine pancreatic ribonuclease A studied by Anfinsen and colleagues has 124 amino acid residues and four internal protein disulfide bonds. It supplied a particularly informative test of the relationship between protein primary structure, protein folding and biological function: recovery could be measured through restored enzyme activity. See the primary sources under ribonuclease A refolding experiment.

Protein denaturation is the loss of a protein's native spatial organization, often with loss of biological function. Changes in temperature, pH or surroundings can disrupt protein secondary structure, protein tertiary structure or protein quaternary structure. Protein denaturation ordinarily preserves the peptide bonds and protein primary structure; it is different from cutting the chain. Recovery by protein folding is possible in some cases, but removing the denaturing conditions does not guarantee that every protein recovers. See Clark, Douglas and Choi: denaturation, environmental conditions and loss of function.

In the diagram, unfolding preserves all eleven peptide bonds. Cleaving the connection between positions 6 and 7 leaves two six-residue fragments: each contains five peptide bonds, so there are $5+5=10$ in total. Simply cooling or otherwise restoring suitable conditions cannot recover the original chain by protein folding alone; the missing covalent bond would have to be remade. Conversely, protein aggregation can impede recovery without breaking any peptide bond. These distinctions explain why loss of function does not by itself reveal whether a protein unfolded, associated with other chains, or suffered chemical damage.

Protein folding is the process by which a polypeptide chain acquires an organized spatial arrangement. The interactions of its amino acid residues with one another and the surroundings favor some arrangements over others. Protein folding can bring chemically useful groups together at an active site without changing their order along the protein backbone. Its importance is practical: knowing a sequence alone does not tell us whether a sample has the structure needed for function. See Cooper: acquiring functional protein structure.

The ribonuclease A refolding experiment showed that an isolated protein could recover its native properties without a pre-existing folded template under suitable laboratory conditions. Anfinsen interpreted this through a thermodynamic hypothesis: the native arrangement minimizes the whole system's Gibbs free energy in the appropriate environment. His Nobel lecture was delivered on 11 December 1972 and published in Science in 1973. The specified environment is part of the claim, not a disposable qualification. See Anfinsen, Principles that Govern the Folding of Protein Chains, Science 181, 223–230 (1973): Nobel lecture, especially p. 223.

This does not imply that every protein rapidly folds unaided. Molecular chaperones can assist protein folding and reduce protein aggregation; required partners, surroundings and time still matter. Goloubinoff and colleagues' 1989 reconstitution experiments demonstrated assistance from two molecular chaperones and ATP in recovering an active enzyme from unfolded chains. This is experimental evidence that assistance can matter even when the chains already have their specified sequences. See Goloubinoff, Christeller, Gatenby and Lorimer, 1989: chaperone-assisted reconstitution of an active enzyme.

Protein structure describes both the chain's chemical organization and its spatial arrangement. Four levels answer different questions: protein primary structure gives the order; protein secondary structure gives recurring local patterns; protein tertiary structure gives one chain's overall arrangement; protein quaternary structure gives the assembly of multiple chains. These are levels of description, not four mandatory stages that every protein must pass through. See Clark, Douglas and Choi: four levels of protein structure.

A polypeptide is a chain of amino acid residues linked by peptide bonds. The term describes chain chemistry; calling a chain a polypeptide alone does not establish that it is folded or functional. The gene expression example N–methionine–alanine–C contains two amino acid residues and one peptide bond; the twelve-residue example under protein contains eleven peptide bonds. See IUPAC-IUB: amino-acid symbols and representation of residues in chains.

Protein targeting directs a protein to its cellular destination. Synthesis in the cytosol does not imply that the protein works there.

For entry into the endoplasmic reticulum, distinguish three questions: does the nascent chain reach the membrane, does part of it cross into the ER lumen, and does a segment remain embedded as a transmembrane protein? Cotranslational protein translocation couples these events to biological translation. A signal peptide can initiate delivery without specifying the eventual destination of the mature protein.

This distinction matters experimentally. Finding a protein in a membrane-containing centrifugation pellet could reflect surface binding or protein aggregation. The microsomal protein import experiment instead asks whether an intact membrane prevents an external protease from reaching the product. That tests accessibility across a barrier, rather than proximity to it.

A Western blot detects selected proteins after their separation and transfer to a membrane, using antibodies. In the yeast cross-species complementation experiment, detection helps distinguish failed protein production from failure of an expressed protein to restore growth.

The useful idea is to preserve where proteins migrated in gel electrophoresis, then ask which positions retain an antibody. Western blot separation, Western blot transfer and Western blot antibody detection answer different questions. A band is evidence of retained label at a position; Western blot band interpretation requires Western blot controls before assigning identity or comparing abundance.

An antibody is a protein that recognizes particular molecular targets through binding. Antibodies participate in immunity; laboratory assays such as Western blots exploit their selective binding to detect chosen proteins.

An IgG gives a concrete architecture: two immunoglobulin heavy chains and two immunoglobulin light chains, joined by disulfide bonds. Each arm ends in a paratope assembled from an antibody variable region of each kind of chain. The two paratopes recognize the same epitope in this conventional IgG; the flexible hinge allows different arm separations. The antibody constant regions form the remaining portions. This is an illustrative IgG, rather than the architecture of every antibody format. ^[ref]

Three questions must be kept separate. Antibody specificity asks which antigens are recognized. Antibody affinity describes one paratope–epitope interaction. Avidity describes the combined attachment when several contacts can cooperate. A selective antibody can have modest antibody affinity, and a monoclonal antibody can still show cross-reactivity. For an assay, the practical question is whether the observed readout identifies the intended antigen under the tested conditions; Western blot antibody specificity controls make that question concrete.

A strict functional programming language with parametric polymorphism, algebraic datatypes, exception handling and mutable references.

// Target: computer-science.bigb

Functional programming emphasizes computation by evaluating and composing functions, often using immutable data and expression-based definitions. A pure function has no observable side effects and returns the same result for the same inputs, allowing substitution of equals for equals. Mapping a square function over a list illustrates a direct transformation without an externally updated accumulator. Higher-order functions accept or return functions, making patterns such as mapping and folding reusable. Functional languages differ in strictness and effect handling; the paradigm does not imply that real programs never perform input or output.

Imperative programming describes computation through commands changing program state. Assignment updates a variable, sequencing orders commands and loops repeat updates until a condition changes. To sum a list, an imperative program can maintain an accumulator and add each next element into it. Correctness can be expressed through a loop invariant: after processing a prefix, the accumulator equals that prefix's sum. State changes can be local or observable as a side effect. The paradigm concerns the description of computation, rather than requiring a particular processor architecture.

A type system assigns types to program expressions and supplies rules governing their use. A type constrains permitted operations: in our teaching programming language, int admits integer addition, bool supplies true and false for conditions, and a function type specifies an argument type and a result type. Storage as bits alone does not explain these distinctions; the type system determines whether an expression can serve as an argument, a condition or an operand.

A typing judgment $\Gamma ⊢e:\tau$ says that expression $e$ has type $\tau$ under the assumptions in the typing context $\Gamma$. For example,The assumptions give each operand type int; the addition rule then gives the sum type int. Changing $y$ to type bool prevents this derivation. Our teaching programming language has distinct int and bool types and no implicit conversions between them.

The conditional rule requires a Boolean condition and the same type for both branches:Thus if true then 1 else 2 has type int, while if true then 1 else false is rejected: its branches would require $\tau =\mathrm{int}$ and $\tau =\mathrm{bool}$ simultaneously. Even a branch that will not execute is checked by this rule. This is a rule of this particular type system; a different programming language can choose different rules. ^[ref]

The useful feature is compositional reasoning: after checking the parts, a rule explains how to check the whole. The function type diagram shows this for a call. Type inference can discover the required types automatically, and type variables let one express relationships that recur across many concrete types. The result is both a practical early error detector and a small, readable derivation explaining why an expression fits its intended use.

The guarantee depends on the rules and execution model. Type safety can exclude specified failures such as adding a Boolean or calling an integer as a function. It does not by itself establish every desired runtime property or guarantee that execution terminates. A type system that permits unrestricted recursion can accept a computation that runs forever; exception handling also needs its own account of permitted outcomes.

Exception handling transfers control from an operation that signals an exceptional condition to a matching handler. A parser can signal a malformed input instead of returning an ordinary result; a surrounding handler can report or recover from that case. Propagation may unwind intervening call frames, so cleanup constructs specify what happens to resources during exit. Checked and unchecked exception rules differ by language. Catching an exception does not itself restore an invariant damaged before it was raised, and silently discarding every exception can hide a failed computation.

// Target: computer-science.bigb

Java is a class-based, statically typed programming language whose ordinary implementation compiles source into bytecode for a Java virtual machine. Its type system, exception rules and object model specify program behaviour; the virtual machine supplies execution and managed storage. Generics in Java add parameterized types checked largely at compilation, with type erasure shaping their runtime representation. The Java language, the virtual-machine specification and a particular vendor's development kit are separate layers, so an implementation detail should not be mistaken for a universal language rule.^[ref]

// Target: computer-science.bigb

Object-oriented programming organizes software around objects with associated state and operations. A method call requests behaviour through an object's interface; encapsulation can hide its internal representation. In class-based systems, a software class describes common structure and behaviour, while polymorphism allows callers to use a shared interface across different implementations. For example, circle and rectangle objects can both implement an area operation using different formulas. Inheritance is one mechanism for reuse and specialization, not a guarantee of correct substitution. Some object systems use prototypes rather than classes.

// Target: computer-science.bigb

Python is a general-purpose programming language with dynamic typing, functions, software classes, exception handling and modules. It supports procedural, object-oriented programming and functional programming. Guido van Rossum developed it to combine readable high-level data types with extensibility and access to operating system facilities; he began the implementation in 1989 and released it publicly in 1991.^[ref]

The standard-library ast module exposes Python abstract syntax trees. For example, parsing 2 + 3 * 4 in expression mode produces an addition whose right operand is a multiplication: the tree records operator precedence, and ordinary integer arithmetic evaluates the expression to 14. The abstract syntax tree can be inspected or transformed before compilation. The tree examples here use the Python 3.14 schema, since the schema can change between language versions.^[ref]

Encoded instructions executed by a central processing unit. An abstract syntax tree instead describes programming language constructs and their nesting.

An interpreter executes a program's operations according to its programming language semantics. It can recursively evaluate an abstract syntax tree, or follow an instruction sequence using an execution state such as a stack and an instruction pointer. It need not repeatedly read source code characters, and it need not use an abstract syntax tree at all.

Compilation and interpretation can coexist. In CPython, Python source code is compiled into bytecode for execution by an interpreter; its bytecode is not promised to remain stable between releases.^[ref] The Python 3.14 compile function accepts text or an abstract syntax tree and can produce a code object, which eval or exec can execute.^[ref] These operations make translation and execution separately accessible without requiring them to live in different applications.

Just-in-time compilation gives another combination: an interactive implementation can translate a submitted program expression into machine code and then execute it immediately. The LLVM 20.1.0 tutorial demonstrates this by adding an intermediate representation module to its just-in-time compilation facility, looking up the generated function, and calling it.^[ref] Thus calling a programming language permanently "compiled" or "interpreted" hides an implementation choice: ask which representation is translated, which is executed, and when.

A compiler translates a program from one representation to another while aiming to preserve its programming language semantics. Its input might be source code or an intermediate representation; its output might be another programming language, bytecode, an intermediate representation, or machine code. Producing machine code is therefore one possible destination, rather than the definition of compilation. For example, the LLVM 20.1.0 tutorial translates an abstract syntax tree into an intermediate representation before introducing execution.^[ref]

Compilation can use an abstract syntax tree for checking and transformations such as constant folding before producing machine code. These are useful possibilities, not a compulsory sequence of separate stages for every compiler. The central distinction is between translating a program and executing its operations: a compiler can translate x*(2+3)-4 without knowing the input value of x, whereas an interpreter needs that value to produce this program expression's result.

Different representations expose different questions. Source code preserves what a programmer wrote; an abstract syntax tree exposes grouping; a type system checks permitted combinations; a stack machine makes operand movement explicit. Retaining abstract syntax tree source locations across compilation helps an error message identify the original construct even after constant folding has changed its shape. A malformed x*(2+)-4 is a programming language syntax error; an unavailable x in the valid example is instead a missing input. Locating the failing rule is more helpful than treating both as an unexplained execution failure.

The meaning of constructs in a programming language, including their permitted values and execution behavior. Programming language syntax organizes constructs; a type system and execution rules give further constraints and meaning.