{
  "id": "memory-model",
  "title": "Memory model",
  "lang": "en",
  "source_lang": "en",
  "summary": "A memory model specifies how memory operations behave and which values concurrent computations may observe across programming languages, compilers, and processors.",
  "category": "computer-science",
  "subcategory": "software",
  "type": "concept",
  "aliases": [
    "Memory consistency model",
    "Shared-memory consistency model"
  ],
  "generated_at": "2026-11-03",
  "model": "pro/gpt-6.1-sol",
  "url": "https://aiwiki.page/en/memory-model/",
  "translations": {
    "zh-Hans": {
      "url": "https://aiwiki.page/zh/memory-model/",
      "json": "https://aiwiki.page/zh/memory-model.json"
    }
  },
  "sections": [
    {
      "heading": "",
      "text": "A memory model specifies the rules governing reads, writes, and other operations on memory. In concurrent computing, its central task is to define which values a read may return when several threads or processors access shared data. It establishes what ordering and visibility guarantees a program can rely on, including the effects of atomic operations, locks, and memory barriers. A memory model is therefore a contract between programs and their execution environment, not simply a description of how physical memory is built.\n\nMemory models exist at several levels. A programming language defines the behavior of source programs; an instruction set architecture defines the behavior of machine instructions; and a compiler must translate between these levels without violating the source language’s guarantees. The distinction matters because both compilers and processors can change the effective order of memory operations while preserving the behavior required by their respective specifications.\n\nThe term also has broader and historical meanings, including rules for object representation, addressability, and segmented address spaces. In modern discussions of parallel software, however, it usually refers to the semantics of shared-memory interaction. These semantics determine whether a synchronization technique is correct, whether an optimization is permitted, and whether a program remains valid when moved between architectures."
    },
    {
      "heading": "Scope and levels of specification",
      "text": "A memory model describes an abstract machine rather than a particular arrangement of memory chips. Its subjects include memory locations, access operations, execution agents, and the relationships among those operations. At the language level, locations may correspond to objects or parts of objects. At the hardware level, accesses typically refer to address ranges with specified sizes, alignment requirements, and memory attributes. These differences mean that a language-level atomic variable cannot be understood solely by examining the processor instruction that implements it.\n\nThree properties recur throughout the subject. Atomicity concerns whether an operation can be observed as an indivisible action rather than as several partial updates. Ordering concerns which relationships among operations must be preserved. Visibility concerns which writes a reader is permitted to observe. These properties are related but not interchangeable. An indivisible write does not necessarily order accesses to other locations, and a barrier that constrains ordering does not necessarily make an arbitrary multiword update indivisible.\n\nA language memory model also interacts with object lifetime, initialization, alignment, and aliasing. In C and C++, for example, an access must satisfy object and type rules as well as concurrency rules. A machine instruction that appears to load the expected bits does not establish that the source program has defined behavior. Conversely, a language implementation may use several instructions or a library lock to provide one abstract atomic operation.\n\nMemory consistency must be distinguished from virtual memory and the memory hierarchy. Virtual memory concerns address translation, protection, and the relationship between virtual and physical address spaces. A memory hierarchy organizes storage by capacity, latency, and bandwidth. Neither concept, by itself, specifies which values concurrent reads may observe. Similarly, non-uniform memory access describes unequal access costs across a machine, not a complete consistency policy.\n\nHistorically, “memory model” also denoted address-space conventions used by compilers for processors such as the Intel 8086. Tiny, small, medium, compact, large, and huge models differed in assumptions about code and data segments and in the use of near and far pointers. That usage concerned how programs represented and addressed memory, rather than the ordering of concurrent accesses. The two senses share a concern with the programmer-visible abstraction of memory but answer substantially different questions."
    },
    {
      "heading": "Sequential consistency and observable executions",
      "text": "The best-known reference model is sequential consistency, formulated by Leslie Lamport in 1979. A multiprocessor execution is sequentially consistent if its result is the same as that of some single sequential ordering of all processors’ operations, with each processor’s operations appearing in its specified program order. The definition does not require processors to execute one at a time. It requires their observable behavior to admit that explanation.\n\nFor ordinary read and write events, sequential consistency can be described using a total order \\(S\\). If \\(a\\) precedes \\(b\\) in a thread’s program order, written \\(a <_{\\mathrm{po}} b\\), then:\n\n\\[a <_{\\mathrm{po}} b \\implies a <_S b.\\]\n\nEach read returns the value of the most recent preceding write to the same location in \\(S\\), including an initial write where appropriate. Thus, sequential consistency combines a global order with a rule for determining the source of each read. The global order need not match a unique physical timeline.\n\nA standard example is the store-buffering test. Initially, \\(x=y=0\\), and two threads perform:\n\nThread 0                 Thread 1\nx = 1                    y = 1\nr0 = y                   r1 = x\n\nUnder sequential consistency, the outcome \\(r0=r1=0\\) is impossible. For the first read to return zero, it must precede the other thread’s write to \\(y\\); likewise, the second read must precede the write to \\(x\\). Combined with each thread’s write-before-read order, these constraints form a cycle, which no total order can satisfy.\n\nSequential consistency is intuitive but does not provide every property a programmer might want. It does not make several operations into one transaction. Two threads can both read a counter’s old value and then write the same incremented value in a perfectly sequentially consistent execution. Preventing such lost updates requires an indivisible read-modify-write operation or mutual exclusion. Nor does sequential consistency guarantee that a waiting thread eventually runs or observes progress; scheduling and liveness are separate concerns.\n\nSequential consistency also differs from linearizability, a correctness condition for concurrent objects. Linearizability requires operations to appear to take effect at individual points between their invocation and response, while respecting real-time precedence between nonoverlapping operations. Sequential consistency preserves each participant’s order but does not impose that same general real-time requirement. This distinction matters when reasoning about queues, counters, and other abstractions built above primitive memory operations."
    },
    {
      "heading": "Processor mechanisms and relaxed hardware behavior",
      "text": "Modern processors exploit concurrency within and between instruction streams. They overlap memory accesses, execute instructions speculatively, and delay the global effects of stores. A hardware memory model specifies which externally observable behaviors these mechanisms may produce. It does not normally require software to understand their exact implementation.\n\nA particularly important mechanism is the store buffer. A processor can place a write in a local buffer and continue before the write becomes visible to other processors. A later load from a different address may complete while that write remains buffered. In the store-buffering test, both processors can therefore read zero before either buffered write becomes visible to the other. This behavior does not require the processor to rewrite the instruction sequence; delayed propagation is enough.\n\nFor ordinary cacheable, write-back memory, x86 is commonly described using a total-store-order model. It preserves many ordering relationships but permits the characteristic store-to-load relaxation between different locations. A processor can also forward a buffered store to its own later load of the same location. Consequently, the slogan that x86 “executes memory accesses in order” is too strong. Ordering rules also differ for special memory types, non-temporal operations, and interactions with devices.\n\nArm and RISC-V permit additional behaviors unless software uses suitable dependencies, ordered instructions, or barriers. Their specifications distinguish different classes of ordering and provide instructions for imposing them. RISC-V’s base relaxed model is called RVWMO, while the Ztso extension supplies stronger ordering guarantees. Architecture names alone are not complete specifications: versions, extensions, access attributes, and instruction variants all matter.\n\nCache coherence is essential but not sufficient to explain these models. Cache coherence generally ensures a consistent ordering of writes to an individual location or coherence unit. A memory consistency model also governs relationships among accesses to different locations. Two variables can each be coherently maintained while a reader observes their updates in an order that a programmer did not expect. Moreover, cache-line granularity is an implementation property, whereas a language’s atomicity and data-race rules are stated in terms of its own memory locations and objects.\n\nHardware descriptions must also distinguish ordering from speculation. A processor may issue an operation speculatively and later discard it while preserving all architecturally required results. Conversely, a visible weak-memory outcome need not demonstrate speculative execution. The memory model constrains architectural observations; it is not a complete account of internal activity, timing, power consumption, or side channels."
    },
    {
      "heading": "Event relations and formal descriptions",
      "text": "Memory models are often specified using events and relations rather than a single narrative about time. Events represent actions such as reads, writes, fences, and read-modify-write operations. A candidate execution identifies the events that occur and the values read. The model then determines whether that candidate is allowed. This approach is especially useful when no single global order of all events is required.\n\nSeveral relations are widely used. Program order, often written \\(\\mathrm{po}\\), relates events within one execution agent. Reads-from, written \\(\\mathrm{rf}\\), identifies the write supplying a read’s value. Coherence order, often written \\(\\mathrm{co}\\), orders writes to the same location. A derived from-read relation links a read to writes that follow its source write in coherence order:\n\n\\[\\mathrm{fr}=\\mathrm{rf}^{-1};\\mathrm{co},\\]\n\nwhere \\(;\\) denotes relational composition. Exact event sets and relation names vary between specifications, but these ideas provide a common vocabulary.\n\nAn axiomatic model constrains combinations of such relations. It may prohibit cycles in a particular graph, require atomic read-modify-write events to remain adjacent in a location’s modification order, or restrict which writes a read can observe. Different models choose different constraints. Simply requiring every conceivable combination of ordering relations to be acyclic would generally impose a stronger model than intended.\n\nA language-level relation of particular importance is happens-before. In simplified presentations of C++ concurrency, it is built from within-thread sequencing and cross-thread synchronization:\n\n\\[\\mathrm{hb}=(\\mathrm{sb}\\cup\\mathrm{sw})^{+},\\]\n\nwhere \\(\\mathrm{sb}\\) means “sequenced before,” \\(\\mathrm{sw}\\) means “synchronizes with,” and \\(+\\) denotes transitive closure. This expresses how an ordering established by synchronization can extend across surrounding ordinary operations. The precise standard wording is version-dependent, and happens-before alone is not a complete definition of all permitted atomic outcomes.\n\nOperational models offer a complementary description. They define an abstract machine with states and transitions, perhaps including per-thread store buffers, write-propagation state, or speculative structures. Executions are generated by taking permitted transitions. Such models can be easier to visualize, whereas axiomatic models can be convenient for comparing allowed outcomes and mechanizing consistency checks. Establishing equivalence between two presentations is a substantive verification task.\n\nThese techniques connect memory models to formal verification. A useful model must be precise enough to support proofs while remaining applicable to real compilers and processors. Apparent simplifications can exclude legitimate implementations or admit behaviors that undermine programming-language guarantees. The choice of abstraction therefore affects both practical testing and the mathematical foundations of concurrent programs."
    },
    {
      "heading": "Language memory models and data races",
      "text": "A language memory model defines concurrency at the level where programmers write expressions, manipulate objects, and invoke synchronization operations. Its rules must account for transformations that are valid in single-threaded code but potentially surprising when another thread observes the same data. Keeping a variable in a register, eliminating repeated loads, combining stores, or moving a computation can all change unsynchronized interthread observations.\n\nThe central distinction is between an execution with a data race and a race-free execution. In the C++ model, a data race arises, roughly, when conflicting potentially concurrent actions access the same memory location, at least one modifies it, at least one is non-atomic, and neither is ordered before the other by happens-before. A data race is a specific technical condition, not a synonym for every race condition. A program using only atomic operations can still contain a logical race that produces an unwanted result.\n\nMany language models support a principle known as data-race freedom, commonly expressed as DRF-SC: under appropriate conditions, correctly synchronized programs enjoy sequentially consistent behavior. This allows ordinary data structures to be reasoned about using familiar interleavings when all conflicting accesses are properly ordered. The exact theorem depends on the language and on which synchronization operations the program uses; explicit relaxed atomics complicate any blanket formulation.\n\nC++11 and C11 introduced standardized language memory models with threads, atomic operations, and memory-order parameters. In both languages, a data race involving ordinary objects leads to undefined behavior. This is stronger than permitting a stale or unexpected value: the language imposes no requirements on that execution. The rule enables optimizations based on the assumption that a defined program does not contain such races.\n\nJava takes a different approach. Its revised memory model, developed through JSR-133 and delivered with Java 5 in 2004, defines guarantees involving monitors, volatile variables, thread lifecycle operations, and final fields. Racy Java programs do not acquire the unrestricted semantics associated with C++ undefined behavior, but they can still have counterintuitive results. Java also distinguishes the atomicity guarantees for different kinds of access; ordinary nonvolatile long and double accesses have historically had weaker specification guarantees than volatile accesses.\n\nOther languages impose different boundaries. Rust’s safe abstractions and type system prevent many data races, while unsafe code and atomic APIs still require memory-model reasoning. JavaScript supports shared-memory concurrency through SharedArrayBuffer and Atomics, despite much ordinary JavaScript programming using event loops. Its atomic operations have specified ordering semantics rather than the C++ menu of per-operation memory-order arguments. A familiar keyword such as “atomic” therefore does not imply identical behavior across languages."
    },
    {
      "heading": "Atomic operations and synchronization",
      "text": "An atomic operation is indivisible in the sense guaranteed by its specification. Atomic loads and stores protect an individual access against tearing and participate in defined ordering relationships. Atomic read-modify-write operations, such as fetch-and-add or compare-and-exchange, additionally combine reading and updating into one abstract operation. None of these properties automatically turns a sequence of operations on several variables into a single indivisible transaction.\n\nC++ and C provide several memory-order choices. Relaxed operations retain atomicity and the relevant per-object ordering guarantees but do not by themselves establish cross-thread synchronization for unrelated objects. Release operations can publish earlier actions, while acquire operations can make those actions available to subsequent computation when the required communication relationship exists. Acquire-release operations combine both roles, and sequentially consistent operations participate in an additional total order subject to the language’s consistency rules.\n\nA publication example illustrates the mechanism:\n\nint payload = 0;\nstd::atomic<bool> ready{false};\n\n// Producer\npayload = 42;\nready.store(true, std::memory_order_release);\n\n// Consumer\nif (ready.load(std::memory_order_acquire)) {\n    use(payload);\n}\n\nAssume these are the only relevant accesses, initialization is complete before the threads run, and use only reads the published value. If the acquire load reads the value written by the release store, the store synchronizes with the load. The write to payload therefore happens before the consumer’s read, and that read obtains 42. If the load returns false, the example makes no claim that publication has occurred.\n\nChanging both atomic accesses to relaxed operations removes that synchronization. Atomicity of ready remains, but it no longer orders the ordinary accesses to payload. If the consumer enters the branch and reads payload without another ordering mechanism, the ordinary accesses form a data race. This is a language-semantic failure, not merely a risk that a processor cache has not been refreshed.\n\nHigher-level synchronization primitives package these relationships. Unlocking a mutex and a subsequent successful lock acquisition can establish the required ordering between critical sections. Thread creation and completion operations can also provide specified synchronization. Condition variables coordinate waiting and notification, but access to the associated shared state still depends on the surrounding synchronization protocol.\n\nAn atomic variable’s existence does not guarantee a lock-free implementation. Depending on its size, alignment, type, and target, a library may implement it using a lock. Lock-free algorithms concern system-wide progress despite delays to individual threads; wait-freedom provides a stronger per-operation progress guarantee. These are separate from memory ordering, although correct nonblocking algorithms typically require careful use of both."
    },
    {
      "heading": "Litmus tests and characteristic weak-memory outcomes",
      "text": "A memory-model litmus test is a small concurrent program designed to distinguish permitted from forbidden outcomes. It usually specifies initial values, a few operations per participant, and a final-state condition. Such tests are valuable because a handful of accesses can expose a fundamental difference between models. Their interpretation always depends on the abstraction level: hardware assembly, language atomics, and ordinary language variables are not interchangeable.\n\nThe store-buffering example distinguishes sequential consistency from models that permit a store to remain pending while a later independent load completes. The converse pattern, usually called load buffering, is:\n\nInitially x = y = 0\n\nThread 0                 Thread 1\nr0 = x                   r1 = y\ny = 1                    x = 1\n\nThe outcome \\(r0=r1=1\\) cannot arise under sequential consistency. It can be admitted by some weak-memory specifications for suitable independent operations. Whether it is allowed depends on the particular architecture or language model and on dependencies or ordering instructions in the actual program. The names “store buffering” and “load buffering” identify test patterns, not universal architectural explanations.\n\nThe message-passing test captures publication:\n\nInitially data = flag = 0\n\nWriter                   Reader\ndata = 1                 r0 = flag\nflag = 1                 r1 = data\n\nThe interesting outcome is \\(r0=1\\) together with \\(r1=0\\): the reader observes the signal without observing the data that logically precedes it. Release/acquire publication can forbid this outcome under the required reads-from relationship. At the hardware level, suitable instructions or barriers provide the corresponding ordering. At the C++ source level, using ordinary unsynchronized variables for this example creates a data race, so the hardware litmus interpretation cannot simply be transferred to that program.\n\nAnother family, independent reads of independent writes or IRIW, involves two writers updating different locations and two readers examining those locations in opposite orders. A characteristic outcome has each reader observe its first location as updated and its second as unchanged. This probes whether the observations can be reconciled with the relevant global-order requirements. The answer depends on access ordering as well as the model’s write-propagation guarantees.\n\nThis leads to multiple-copy atomicity, which concerns the way writes become observable across processors, subject to the model’s treatment of local forwarding. A system that allows a write to propagate to different observers at different stages admits patterns unavailable under stronger propagation rules. Nevertheless, multiple-copy atomicity alone does not imply sequential consistency, and IRIW is not a universal one-question test for it.\n\nA forbidden outcome is especially informative: observing it can reveal an implementation error, an incorrect model, or a flawed test. Failing to observe an allowed outcome proves much less. Rare scheduling, compiler choices, topology, and microarchitectural timing can prevent a behavior from appearing in extensive experiments even though the specification permits it."
    },
    {
      "heading": "Compiler transformations and implementation mappings",
      "text": "A compiler must preserve the behaviors required by the source language while targeting a machine with potentially different guarantees. This is not the same as preserving the textual order of instructions. Source-level operations may disappear, combine, or expand into several instructions. Correctness concerns the relationship between observable source executions and observable target executions.\n\nFor an ordinary single-threaded object, repeated reads can often be replaced by a previously computed value. In concurrent code, a programmer may expect another thread to change the object between reads. Whether that expectation is valid depends on the language rules. In C and C++, unsynchronized polling of an ordinary variable is not rescued by the fact that the generated machine code once happened to reload it. The compiler can reason on the assumption that defined executions contain no data race.\n\nThe keyword volatile illustrates the danger of transferring terminology between languages. In C and C++, volatile-qualified accesses support particular implementation and observable-access requirements, but they are not a general replacement for atomics or locks. In Java, volatile accesses have explicit interthread ordering semantics. The same spelling therefore denotes substantially different contracts.\n\nImplementation mappings connect source operations to target instructions. On x86, acquire loads and release stores can often use ordinary load and store instructions for suitable cacheable memory, while the compiler still restricts transformations around them. Stronger operations may require locked instructions or fences. On AArch64, load-acquire and store-release instructions provide ordering directly, while other mappings use barriers. Exact choices depend on the operation, target features, and compiler strategy.\n\nA memory barrier may exist at the compiler level, hardware level, or both. A compiler barrier constrains instruction motion by the compiler but need not emit a hardware ordering instruction. A hardware fence constrains specified architectural behaviors but cannot repair an invalid source program by magic. Portable synchronization requires a construct whose language semantics and implementation mapping cover both layers.\n\nMapping correctness is also compositional. Separately compiled functions, libraries, inline assembly, and language interoperability must agree about the ordering obligations they impose and discharge. An application binary interface can specify calling conventions and data layout without fully specifying the language-level synchronization protocol around shared objects.\n\nDependencies require similar care. An address dependency between two machine loads may enforce ordering on an architecture, but a source expression that appears dependent can be simplified by optimization. Historical attempts to expose dependency-based ordering through C++ memory_order_consume encountered precisely this tension between efficient hardware mechanisms and portable compiler analysis. An assembly-level argument is therefore not automatically a valid source-level proof."
    },
    {
      "heading": "Heterogeneous systems, devices, and persistent memory",
      "text": "Memory-model reasoning extends beyond uniform CPU threads. A graphics processing unit may organize work into lanes, warps or subgroups, thread blocks, and a device-wide execution domain. Ordering an access within one group does not necessarily make it available to every group or to the host processor. Many accelerator programming environments therefore attach a scope to synchronization operations.\n\nIn CUDA, for example, atomic and synchronization facilities distinguish block, device, and system scopes where supported. OpenCL similarly defines memory orders and scopes for relevant atomic operations. A complete communication argument must match the memory region, participants, scope, and execution dependencies. Strong ordering at an insufficient scope does not provide the same contract as synchronization covering both communicating agents.\n\nMemory spaces introduce another dimension. GPU local or shared storage can have a lifetime and visibility domain different from global memory. A work-group or block barrier coordinates a particular set of threads, not every thread executing a kernel. Host-device communication may depend on kernel completion, stream or queue ordering, events, and explicit transfer or mapping operations. The programming environment specifies how these operations relate to memory visibility.\n\nDevice access also differs from ordinary cacheable shared memory. Memory-mapped registers can have side effects: reading may acknowledge an interrupt, while writing may initiate an operation. A device driver must use the operating system and architecture’s specified accessors, barriers, and direct-memory-access synchronization mechanisms. CPU cache coherence does not establish that a peripheral has completed an operation or consumed a buffer.\n\nPersistent memory adds the distinction between visibility and durability. A write can become observable to other processors while still residing in a volatile cache. Making an update survive power loss can require explicit writeback and ordering operations, depending on the platform’s persistence domain. Thus, an execution has both communication-ordering questions and crash-recovery questions.\n\nPersistent data structures must also account for intermediate durable states. If a new node becomes persistent but the pointer linking it into a structure does not, recovery observes a different situation from one in which the pointer persists first. Logging, recovery protocols, and transactions address these issues at higher levels. A persistence barrier is not interchangeable with a thread-synchronization operation merely because both constrain some form of ordering.\n\nThese settings demonstrate that “shared memory” does not identify a single universal contract. The relevant observers may be CPU cores, accelerator groups, devices, or a future execution after a crash, and each communication boundary has its own specified guarantees."
    },
    {
      "heading": "Historical development, validation, and open problems",
      "text": "Memory-model research developed alongside the need to make parallel machines efficient without rendering their software unmanageable. Lamport’s 1979 definition of sequential consistency supplied a precise baseline. Subsequent multiprocessor designs exposed the performance costs of enforcing all of its ordering requirements. Store buffering, overlapping accesses, and scalable propagation mechanisms motivated models that preserved fewer orders while providing explicit synchronization.\n\nDuring the 1980s and 1990s, researchers studied processor consistency, weak ordering, release consistency, and related alternatives. Work by Sarita Adve and Mark Hill in 1990 helped establish the importance of defining models around properly synchronized programs. The enduring insight was that ordinary data accesses could use efficient implementations while synchronization carried the ordering needed for understandable program behavior.\n\nLanguage standardization made the compiler dimension unavoidable. A processor specification alone could not determine the behavior of optimized Java, C, or C++ source. The Java memory-model revision in 2004 and the C and C++ standards of 2011 were major milestones. These models connected object-level semantics, synchronization libraries, compiler transformations, and hardware mappings within language specifications.\n\nValidation now combines several methods. Litmus-test tools such as herd7 explore candidate executions under formal models, while hardware test generators exercise actual machines. Model checkers explore interleavings or weak-memory executions of bounded programs. The state space grows rapidly, so practical tools use reductions and other techniques to avoid exploring equivalent cases unnecessarily. Proof assistants can support machine-checked arguments about particular models, programs, and compiler transformations.\n\nOne persistent problem is out-of-thin-air behavior: a read value seems justified only by another computation that, directly or indirectly, depends on that same value. Excluding these circular explanations while retaining useful optimizations has proved difficult. Simple coherence rules and basic happens-before constraints do not by themselves settle every case. Language-model research therefore studies dependencies, causality conditions, operational semantics, and restrictions on transformations.\n\nAnother challenge is keeping specifications aligned across evolving systems. A language revision, compiler optimization, architecture extension, or accelerator API can alter assumptions used in an older correctness proof. Experiments can detect mismatches, but cannot establish universal correctness from finite observations. Formal proofs can establish strong results, but only relative to the models and implementation details included in their assumptions.\n\nSecurity creates a further boundary. An execution can satisfy its architectural memory model while speculative activity leaves timing or cache effects observable through side channels. Memory-order correctness therefore does not imply information security. Architectural consistency, speculative execution, and information-flow guarantees describe different aspects of the same computation, and verification must state explicitly which observations it includes."
    }
  ],
  "links": [
    "concurrent-computing",
    "programming-language",
    "compiler",
    "aliasing",
    "virtual-memory",
    "memory-hierarchy",
    "non-uniform-memory-access",
    "mutual-exclusion",
    "cpu-cache",
    "cache-coherence",
    "formal-verification",
    "race-condition",
    "type-system",
    "javascript",
    "atomic-operation",
    "synchronization-computing",
    "mutex",
    "graphics-processing-unit",
    "cuda",
    "opencl",
    "device-driver",
    "operating-system",
    "database-transaction",
    "proof-assistant",
    "information-security"
  ],
  "sources": [],
  "license": "https://creativecommons.org/licenses/by/4.0/"
}