Scrape wikipedia-science: 9986 new, 3580 updated, 13927 total (kb-cron)

data/en.wikipedia.org/wiki/BOOPSI-0.md

@@ -0,0 +1,21 @@
+---
+title: "BOOPSI"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/BOOPSI"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:31:31.816585+00:00"
+instance: "kb-cron"
+---
+
+BOOPSI (Basic Object Oriented Programming System for Intuition) is an object-oriented programming system for AmigaOS. It extends the AmigaOS windowing environment (Intuition) with an object-oriented subsystem allowing a hierarchy of object classes in which every class defines a single GUI widget or interface event.
+BOOPSI made it easier for developers to create their own system of widgets and create standardized graphical user interfaces. Magic User Interface and ReAction are examples of complete widget toolkits built on BOOPSI. Both toolkits have become popular with Amiga software programmers to generate and maintain graphical user interfaces.
+The object-oriented design brings advantages such as straightforward coupling of objects with other objects. For example, a programmer may link a numerical input field and a sliding control, where if the user adjusts the sliding control the numerical value in the input field changes automatically.
+BOOPSI was officially introduced with AmigaOS 2.0 and was further extended in later releases.
+
+
+== References ==
+
+
+== External links ==
+How it works BOOPSI at Codewiz.org

data/en.wikipedia.org/wiki/BURS-0.md

@@ -0,0 +1,21 @@
+---
+title: "BURS"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/BURS"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:31:34.212908+00:00"
+instance: "kb-cron"
+---
+
+BURS (bottom-up rewrite system) theory tackles the problem of taking a complex expression tree or intermediate language term and finding a good translation to machine code for a particular architecture. Implementations of BURS often employ dynamic programming to solve this problem.
+BURS can also be applied to the problem of designing an instruction set for an application-specific instruction set processor.
+
+
+== References ==
+A. V. Aho, M. Ganapathi, and S. W. K. Tjiang. Code generation using tree matching and dynamic programming. ACM Transactions on Programming Languages and Systems, 11(4):491-516, October 1989.
+Robert Giegerich and Susan L. Graham, editors. Code Generation - Concepts, Tools, Techniques. Workshops in Computing. Springer-Verlag, Berlin, Heidelberg, New York, 1992.
+
+
+== External links ==
+https://strategoxt.org/Transform/BURG – short description of BURG including additional references to BURS and BURG

data/en.wikipedia.org/wiki/Bandelet_(computer_science)-0.md

@@ -0,0 +1,24 @@
+---
+title: "Bandelet (computer science)"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Bandelet_(computer_science)"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:31:22.199855+00:00"
+instance: "kb-cron"
+---
+
+Bandelets are an orthonormal basis that is adapted to geometric boundaries. Bandelets can be interpreted as a warped wavelet basis. The motivation behind bandelets is to perform a transform on functions defined as smooth functions on smoothly bounded domains. As bandelet construction utilizes wavelets, many of the results follow. Similar approaches to take account of geometric structure were taken for contourlets and curvelets.
+
+
+== See also ==
+Wavelet
+Multiresolution analysis
+Scale space
+
+
+== References ==
+
+
+== External links ==
+Bandelet toolbox Archived 2007-02-19 at the Wayback Machine on MatLab Central

data/en.wikipedia.org/wiki/Behavior_authoring-0.md

@@ -0,0 +1,23 @@
+---
+title: "Behavior authoring"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Behavior_authoring"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:31:23.443964+00:00"
+instance: "kb-cron"
+---
+
+Behavior authoring is a technique that is widely used in crowd simulations and in simulations and computer games that involve multiple autonomous or non-player characters (NPCs). There has been growing academic and industry interest in the behavioral animation of autonomous actors in virtual worlds. However, it remains a considerable challenge to author complicated interactions between multiple actors in a way that balances automation and control flexibility.
+Several varieties of behavior authoring systems have been created.
+
+
+== The BML Sequencer and Smartbody ==
+Behavior Markup Language (BML) is a tool for describing autonomous actor behavior in simulations and computer games. SmartBody is a framework for animation of artificial intelligence conversation agents to provide a more lifelike simulation. Combining both of these concepts, the BML sequencer is a tool to allow artists to create SmartBody compliant BML animation sequences for multiple virtual humans. SmartBody allows for complex behavior realization, synchronizing speech recordings with non-verbal behaviors by using the Behavior Markup Language (BML). However, there remain two problems for using BML and SmartBody to achieve the vision that an artist has for animating the character: the authoring problem and multi-party behavior synchronization. The BML Sequencer addresses both.
+
+
+== Behavior authoring in real-time strategy games ==
+Behavior authoring for computer games consists of first writing the behaviors in a programming language, iteratively refining these behaviors, testing the revisions by executing them, identifying new problems and then refining the behaviors again.
+
+
+== References ==

data/en.wikipedia.org/wiki/Behavioral_modeling_in_computer-aided_design-0.md

@@ -0,0 +1,21 @@
+---
+title: "Behavioral modeling in computer-aided design"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Behavioral_modeling_in_computer-aided_design"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:31:24.649658+00:00"
+instance: "kb-cron"
+---
+
+In computer-aided design, behavioral modeling is a high-level circuit modeling technique where behavior of logic is modeled. 
+The Verilog-AMS and VHDL-AMS languages are widely used to model logic behavior.
+
+
+== Other modeling approaches ==
+Register transfer level modeling: logic is modeled at register level
+Structural modeling: logic is modeled at both register level and gate level
+
+
+== References ==
+Analog Behavioral Modeling with the Verilog-A Language by Dan FitzPatrick, Ira Miller.

data/en.wikipedia.org/wiki/Bidirectionalization-0.md

@@ -0,0 +1,22 @@
+---
+title: "Bidirectionalization"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Bidirectionalization"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:31:25.829564+00:00"
+instance: "kb-cron"
+---
+
+In computer science, bidirectionalization refers to the process of given a source-to-view transformation (automatically) finding a mapping from the original source and an updated view to an updated source.
+
+
+== See also ==
+Bidirectional transformation
+Inverse function
+Reversible computing
+View (SQL)
+
+
+== Further reading ==
+Janis Voigtländer, Zhenjiang Hu, Kazutaka Matsuda, and Meng Wang. Combining Syntactic and Semantic Bidirectionalization. International Conference on Functional Programming 2010.

data/en.wikipedia.org/wiki/Bit-oriented_protocol-0.md

@@ -0,0 +1,24 @@
+---
+title: "Bit-oriented protocol"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Bit-oriented_protocol"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:31:26.985486+00:00"
+instance: "kb-cron"
+---
+
+A bit-oriented protocol is a communications protocol that sees the transmitted data as an opaque stream of bits with no semantics, or meaning. Control codes are defined in terms of bit sequences instead of characters. Bit oriented protocol can transfer data frames regardless of frame contents. It can also be stated as "bit stuffing".
+Synchronous framing High-Level Data Link Control may work like this:
+
+Each frame begins and ends with a special bit pattern 01111110, called a flag byte.
+A bit stuffing technique is used to prevent the receiver from detecting the special flag byte in user data e.g. whenever the sender's data link layer encounters 5 consecutive 1 (one) in the data, it automatically stuffs 0 into the outgoing stream.
+
+
+== See also ==
+Byte-oriented protocol
+
+
+== References ==
+
+Linktionary page for bit-oriented protocol

data/en.wikipedia.org/wiki/Bit-serial_architecture-0.md

@@ -0,0 +1,32 @@
+---
+title: "Bit-serial architecture"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Bit-serial_architecture"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:31:28.192019+00:00"
+instance: "kb-cron"
+---
+
+In computer architecture, bit-serial architectures send data one bit at a time, along a single wire, in contrast to bit-parallel word architectures, in which data values are sent all bits or a word at once along a group of wires.  
+All digital computers built before 1951, and most of the early massive parallel processing machines used a bit-serial architecture—they were serial computers.
+Bit-serial architectures were developed for digital signal processing in the 1960s through 1980s, including efficient structures for bit-serial multiplication and accumulation.
+The HP Nut processor used in many Hewlett-Packard calculators operated bit-serially.
+Assuming N is an arbitrary integer number, N serial processors will often take less FPGA area and have a higher total performance than a single N-bit parallel processor.
+
+
+== See also ==
+Serial computer
+1-bit computing
+Bit banging
+Bit slicing
+BKM algorithm
+CORDIC
+
+
+== References ==
+
+
+== External links ==
+Application of FPGA technology to accelerate the finite-difference time-domain (FDTD) method
+BIT-Serial FIR filters with CSD Coefficients for FPGAs

data/en.wikipedia.org/wiki/Block_contention-0.md

@@ -0,0 +1,26 @@
+---
+title: "Block contention"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Block_contention"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:31:29.375680+00:00"
+instance: "kb-cron"
+---
+
+In database management systems, block contention (or data contention) refers to multiple processes or instances competing for access to the same index or data block at the same time. In general this can be caused by very frequent index or table scans, or frequent updates. Concurrent statement executions by two or more instances may also lead to contention, and subsequently busy waiting for the process without the lock.
+
+
+== Solutions ==
+To reduce contention for table blocks due to delete, select or update statements, reduce the number of rows per block. This can be done by using a smaller block size.
+To reduce contention for table blocks due to insert statements, increase the number of freelists, or buffer frames.
+To reduce contention for index blocks the best strategy is to implement a reverse index.
+In most situations the goal is to spread queries over a greater number of blocks, to avoid concentrating on any single one.
+
+
+== See also ==
+Resource contention
+Lock (computer science) § Granularity
+
+
+== References ==

data/en.wikipedia.org/wiki/Boolean_hierarchy-0.md

@@ -0,0 +1,285 @@
+---
+title: "Boolean hierarchy"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Boolean_hierarchy"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:31:30.601481+00:00"
+instance: "kb-cron"
+---
+
+The Boolean hierarchy is the hierarchy of Boolean combinations (intersection, union and complementation) of NP sets. Equivalently, the Boolean hierarchy can be described as the class of Boolean circuits over NP predicates. A collapse of the Boolean hierarchy would imply a collapse of the polynomial hierarchy.
+
+
+== Formal definition ==
+BH is defined as follows:
+
+BH1 is NP.
+BH2k is the class of languages which are the intersection of a language in BH2k-1 and a language in coNP.
+BH2k+1 is the class of languages which are the union of a language in BH2k and a language in NP.
+BH is the union of all the BHi classes.
+
+
+== Derived classes ==
+DP (Difference Polynomial Time) is BH2.
+
+
+== Equivalent definitions ==
+Defining the conjunction and the disjunction of classes as follows allows for
+more compact definitions. The conjunction of two classes contains the languages that are the intersection of a language of the first class and a language of the second class. Disjunction is defined in a similar way with the union in place of the intersection.
+
+C ∧ D = { A ∩ B | A ∈ C   B ∈ D }
+C ∨  D = { A ∪ B | A ∈ C   B ∈ D }
+According to this definition, DP = NP ∧ coNP. The other classes of the Boolean hierarchy can be defined as follows.
+
+  
+    
+      
+        
+          
+            
+              B
+              H
+            
+          
+          
+            2
+            k
+          
+        
+        =
+        
+          
+            c
+            o
+            N
+            P
+          
+        
+        ∧
+        
+          
+            
+              B
+              H
+            
+          
+          
+            2
+            k
+            −
+            1
+          
+        
+      
+    
+    {\displaystyle {\mathsf {BH}}_{2k}={\mathsf {coNP}}\wedge {\mathsf {BH}}_{2k-1}}
+  
+
+  
+    
+      
+        
+          
+            
+              B
+              H
+            
+          
+          
+            2
+            k
+            +
+            1
+          
+        
+        =
+        
+          
+            N
+            P
+          
+        
+        ∨
+        
+          
+            
+              B
+              H
+            
+          
+          
+            2
+            k
+          
+        
+      
+    
+    {\displaystyle {\mathsf {BH}}_{2k+1}={\mathsf {NP}}\vee {\mathsf {BH}}_{2k}}
+  
+
+The following equalities can be used as alternative definitions of the classes of the Boolean hierarchy:
+
+  
+    
+      
+        
+          
+            
+              B
+              H
+            
+          
+          
+            2
+            k
+          
+        
+        =
+        
+          ⋁
+          
+            i
+            =
+            1
+          
+          
+            k
+          
+        
+        
+          
+            D
+            P
+          
+        
+      
+    
+    {\displaystyle {\mathsf {BH}}_{2k}=\bigvee _{i=1}^{k}{\mathsf {DP}}}
+  
+
+  
+    
+      
+        
+          
+            
+              B
+              H
+            
+          
+          
+            2
+            k
+            +
+            1
+          
+        
+        =
+        
+          
+            N
+            P
+          
+        
+        ∨
+        
+          ⋁
+          
+            i
+            =
+            1
+          
+          
+            k
+          
+        
+        
+          
+            D
+            P
+          
+        
+      
+    
+    {\displaystyle {\mathsf {BH}}_{2k+1}={\mathsf {NP}}\vee \bigvee _{i=1}^{k}{\mathsf {DP}}}
+  
+
+Alternatively, for every k ≥ 3:
+
+  
+    
+      
+        
+          
+            
+              B
+              H
+            
+          
+          
+            k
+          
+        
+        =
+        
+          
+            D
+            P
+          
+        
+        ∨
+        
+          
+            
+              B
+              H
+            
+          
+          
+            k
+            −
+            2
+          
+        
+      
+    
+    {\displaystyle {\mathsf {BH}}_{k}={\mathsf {DP}}\vee {\mathsf {BH}}_{k-2}}
+  
+
+
+== Hardness ==
+Hardness for classes of the Boolean hierarchy can be proved by showing a reduction from a number of instances of an arbitrary NP-complete problem A. In particular, given a sequence {x1, ...  xm} of instances of A such that xi ∈ A implies xi-1 ∈ A, a reduction is required that produces an instance y such that y ∈ B if and only if the number of xi ∈ A is odd or even:
+
+BH2k-hardness is proved if ⁠
+  
+    
+      
+        m
+        =
+        2
+        k
+      
+    
+    {\displaystyle m=2k}
+  
+⁠ and the number of xi ∈ A is odd
+BH2k+1-hardness is proved if ⁠
+  
+    
+      
+        m
+        =
+        2
+        k
+        +
+        1
+      
+    
+    {\displaystyle m=2k+1}
+  
+⁠ and the number of xi ∈ A is even
+Such reductions work for every fixed k. If such reductions exist for arbitrary k, the problem is hard for PNP[O(log n)].
+
+
+== References ==

data/en.wikipedia.org/wiki/Branch_target_predictor-0.md

@@ -0,0 +1,43 @@
+---
+title: "Branch target predictor"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Branch_target_predictor"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:31:33.003552+00:00"
+instance: "kb-cron"
+---
+
+In computer architecture, a branch target predictor is the part of a processor that predicts the target, i.e., the address of the instruction that is executed next, of a taken conditional branch or unconditional branch instruction before the target of the branch instruction is computed by the execution unit of the processor. 
+Branch target prediction is not the same as branch prediction, which guesses whether a conditional branch will be taken or not-taken in a binary manner.
+In more parallel processor designs, as the instruction cache latency grows longer and the fetch width grows wider, branch target extraction becomes a bottleneck. The recurrence is:
+
+Instruction cache fetches block of instructions
+Instructions in block are scanned to identify branches
+First predicted taken branch is identified
+Target of that branch is computed
+Instruction fetch restarts at branch target
+In machines where this recurrence takes two cycles, the machine loses one full cycle of fetch after every predicted taken branch.  As predicted branches happen every 10 instructions or so, this can force a substantial drop in fetch bandwidth.  Some machines with longer instruction cache latencies would have an even larger loss.  To ameliorate the loss, some machines implement branch target prediction: given the address of a branch, they predict the target of that branch.  A refinement of the idea predicts the start of a sequential run of instructions given the address of the start of the previous sequential run of instructions.
+This predictor reduces the recurrence above to:
+
+Hash the address of the first instruction in a run
+Fetch the prediction for the addresses of the targets of branches in that run of instructions
+Select the address corresponding to the branch predicted taken
+As the predictor RAM can be 5–10% of the size of the instruction cache, the fetch happens much faster than the instruction cache fetch, and so this recurrence is much faster.  If it were not fast enough, it could be parallelized, by predicting target addresses of target branches.
+
+
+== See also ==
+Indirect branch control (IBC)
+Indirect branch prediction barrier (IBPB)
+Indirect branch restricted speculation (IBRS)
+Single thread indirect branch predictor (STIBP)
+
+
+== Further reading ==
+Driesen; Hölzle (1992), Accurate Indirect Branch Prediction
+Ertl; Gregg (2001), The Behavior of Efficient Virtual Machine Interpreters on Modern Architectures
+
+
+== External links ==
+"Branch Target Buffers". (EE461)
+Fog, Agner. "The microarchitecture of Intel, AMD and VIA CPUs" (PDF). Retrieved 2017-08-09.

data/en.wikipedia.org/wiki/C-slowing-0.md

@@ -0,0 +1,28 @@
+---
+title: "C-slowing"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/C-slowing"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:31:35.405877+00:00"
+instance: "kb-cron"
+---
+
+C-slow retiming or C-slowing is a technique used in conjunction with retiming to improve throughput of a digital circuit. Each register in a circuit is replaced by a set of registers in series, where C is the number of registers in each of those sets. This creates a circuit with C independent threads, as if the new circuit contained C copies of the original circuit. A single computation of the original circuit takes C times as many clock cycles to compute in the new circuit. C-slowing by itself increases latency, but throughput remains the same.
+Increasing the number of registers allows optimization of the circuit through retiming to reduce the clock period of the circuit.  In the best case, the clock period can be reduced by a factor of C. Reducing the clock period of the circuit reduces latency and increases throughput. Thus, for computations that can be multi-threaded, combining C-slowing with retiming can increase the throughput of the circuit, with little, or in the best case, no increase in latency.
+Since registers are relatively plentiful in FPGAs, this technique is typically applied to circuits implemented with FPGAs.
+
+
+== See also ==
+Pipelining
+Barrel processor
+
+
+== Resources ==
+Intel® Hyperflex™ Architecture High-Performance Design Handbook § 2.4.1.2. Time Domain Multiplexing at the Wayback Machine (archived 2024-06-12)
+PipeRoute: A Pipelining-Aware Router for Reconfigurable Architectures
+Simple Symmetric Multithreading in Xilinx FPGAs
+Post Placement C-Slow Retiming for Xilinx Virtex (.ppt)
+Post Placement C-Slow Retiming for Xilinx Virtex (.pdf)
+Exploration of RaPiD-style Pipelined FPGA Interconnects
+Time and Area Efficient Pattern Matching on FPGAs

data/en.wikipedia.org/wiki/COSFIRE-0.md

@@ -0,0 +1,15 @@
+---
+title: "COSFIRE"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/COSFIRE"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:15.235511+00:00"
+instance: "kb-cron"
+---
+
+COSFIRE stands for Combination Of Shifted FIlter REsponses.
+COSFIRE is a trainable filter, which can be used for interest point (keypoint) detection and pattern recognition in the field of computer vision.
+
+
+== References ==

data/en.wikipedia.org/wiki/COSYSMO-0.md

@@ -0,0 +1,80 @@
+---
+title: "COSYSMO"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/COSYSMO"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:18.780949+00:00"
+instance: "kb-cron"
+---
+
+The Constructive Systems Engineering Cost Model (COSYSMO) was created by Ricardo Valerdi while at the University of Southern California Center for Software Engineering. It gives an estimate of the number of person-months it will take to staff systems engineering resources on hardware and software projects.  Initially developed in 2002, the model now contains a calibration data set of more than 50 projects provided by major aerospace and defense companies such as Raytheon, Northrop Grumman, Lockheed Martin, SAIC, General Dynamics, and BAE Systems.
+Similar to its predecessor COCOMO, COSYSMO computes effort (and cost) as a function of system functional size and adjusts it based on a number of environmental factors related to systems engineering.
+COSYSMO's central cost estimating relationship, or CER is of the form:
+
+  
+    
+      
+        P
+        
+          M
+          
+            N
+            S
+          
+        
+        =
+        A
+        ×
+        
+          
+            size
+          
+          
+            E
+          
+        
+        ×
+        
+          ∏
+          
+            i
+            =
+            1
+          
+          
+            n
+          
+        
+        E
+        
+          M
+          
+            i
+          
+        
+      
+    
+    {\displaystyle PM_{NS}=A\times {\text{size}}^{E}\times \prod _{i=1}^{n}EM_{i}}
+  
+
+where "Size" is one of four size additive size drivers, and EM represents one of fourteen multiplicative effort multipliers.
+
+
+== See also ==
+Comparison of development estimation software
+Software development effort estimation
+
+
+== Further reading ==
+Valerdi, R., Boehm, B., Reifer, D., COSYSMO: A Constructive Systems Engineering Cost Model Coming Age, 13th INCOSE Symposium, July 2003, Crystal City, VA.
+Valerdi, R., The Constructive Systems Engineering Cost Estimation Model (COSYSMO), University of Southern California, May 2005.
+Valerdi, R., The Constructive Systems Engineering Cost Model (COSYSMO): Quantifying the Costs of Systems Engineering Effort in Complex Systems, VDM Verlag, 2008.
+
+
+== External links ==
+Online COSYSMO Tool
+COSYSMO
+SystemStar Tool
+True COSYSMO
+SEER for Systems Engineering

data/en.wikipedia.org/wiki/CPM-GOMS-0.md

@@ -0,0 +1,38 @@
+---
+title: "CPM-GOMS"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/CPM-GOMS"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:21.152947+00:00"
+instance: "kb-cron"
+---
+
+CPM-GOMS is a variation of the GOMS technique in human computer interaction.  CPM-GOMS stands for two things:  Cognitive Perceptual Motor and the project planning technique Critical Path Method (from which it borrows some elements).
+
+
+== Overview ==
+CPM-GOMS was developed in 1988 by Bonnie John, a former student of Allen Newell.  Unlike the other GOMS variations, CPM-GOMS does not assume that the user's interaction is a serial process, and hence can model multitasking behavior that can be exhibited by experienced users.  The technique is also based directly on the model human processor - a simplified model of human responses.
+Evaluators begin a CPM-GOMS analysis in the same way they would a CMN-GOMS analysis.  However, when the tasks are broken down just to the level where they are still perceptual or motor, the evaluator applies techniques from the model human processor.  The tasks are first joined together serially and then examined to see which actions can be overlapped so that they happen in parallel.  This technique facilitates representation of overlapping and very efficient "chunks" of activity characteristic of expert users.  The estimated times by CPM-GOMS are generally faster since they do not allocate as much time to the "prepare for action"  type operations.
+This is the most difficult GOMS technique to implement.  Therefore, it has the problem of discrepancies between evaluators.  Research is currently being conducted to improve the CPM-GOMS technique so that it can be used without the evaluator having a high level understanding of the GOMS theoretical foundations.
+
+
+== Software ==
+Cogulator, an open source software package, can be used to build CPM-GOMS models
+
+
+== See also ==
+Human information processor model
+KLM-GOMS
+NGOMSL
+CMN-GOMS
+
+
+== References ==
+
+
+=== Notations ===
+This article incorporates text from Dr. G. Abowd: GOMS Analysis Techniques - Final Essay, which has been released into GFDL by its author (see Talk:GOMS).
+
+
+=== Footnotes ===

data/en.wikipedia.org/wiki/CUBIT-0.md

@@ -0,0 +1,24 @@
+---
+title: "CUBIT"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/CUBIT"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:23.567942+00:00"
+instance: "kb-cron"
+---
+
+Cubit, often stylized CUBIT, is a computer user interface system for multi-touch devices, designed by Stefan Hechenberger and Addie Wagenknecht for Nortd Labs. It was developed to "demystify multitouch" technology by using an open-source model for software and hardware. It is a direct competitor of Microsoft Surface.
+
+
+== Purchasing ==
+As of 2 May 2008, Nortd Labs is accepting orders for developer kits named the TouchKit. Kit buyers and users must supply their own projector and camera at a cost estimated at between $1,080 and $1,580 USD.
+As of July 2008, the CUBIT system is for sale, by commission only, and both are rumored to have a two to three-month waiting list.
+
+
+== References ==
+
+
+== External links ==
+Official website, Nortd Labs
+Official website, Nortd production studio

data/en.wikipedia.org/wiki/Canterbury_corpus-0.md

@@ -0,0 +1,32 @@
+---
+title: "Canterbury corpus"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Canterbury_corpus"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:31:36.604991+00:00"
+instance: "kb-cron"
+---
+
+The Canterbury corpus is a collection of files intended for use as a benchmark for testing lossless data compression algorithms.  It was created in 1997 at the University of Canterbury, New Zealand and designed to replace the Calgary corpus. The files were selected based on their ability to provide representative performance results.
+
+
+== Contents ==
+In its most commonly used form, the corpus consists of 11 files, selected as "average" documents from 11 classes of documents,  totaling 2,810,784 bytes as follows.
+
+The University of Canterbury also offers the following corpora. Additional files may be added, so results should be only reported for individual files.
+
+The Artificial Corpus, a set of files with highly "artificial" data designed to evoke pathological or worst-case behavior. Last updated 2000 (tar timestamp).
+The Large Corpus, a set of large (megabyte-size) files. Contains an E. coli genome, a King James bible, and the CIA world fact book. Last updated 1997 (tar timestamp).
+The Miscellaneous Corpus. Contains one million digits of pi. Last updated 2000 (tar timestamp).
+
+
+== See also ==
+Data compression
+
+
+== References ==
+
+
+== External links ==
+Official website

data/en.wikipedia.org/wiki/Captology-0.md

@@ -0,0 +1,32 @@
+---
+title: "Captology"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Captology"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:31:37.780798+00:00"
+instance: "kb-cron"
+---
+
+Captology is the study of computers as persuasive technologies. This area of inquiry explores the overlapping space between persuasion in general (influence, motivation, behavior change, etc.) and computing technology. This includes the design, research, and program analysis of interactive computing products (such as the Web, desktop software, specialized devices, etc.) created for the purpose of changing people's attitudes or behaviors. 
+B. J. Fogg in 1996 derived the term captology from an acronym: Computers As Persuasive Technologies. In 2003, he published the first book on captology, entitled Persuasive Technology: Using Computers to Change What We Think and Do.
+Captology is not the same thing as Behavior Design, according to BJ Fogg who is the person who coined both terms and created the foundation for both areas. 
+
+
+== See also ==
+Is Google Making Us Stupid?
+Humu (software)
+
+
+== References ==
+
+
+== Further reading ==
+Fogg, B.J. (2003). Persuasive Technology: Using Computers to Change What We Think and Do. Morgan Kaufmann Publishers. ISBN 1-558-60643-2.
+Teti, A. (2011). PsychoTech, il punto di non ritorno. La tecnologia che controlla la mente (in Italian). Springer-Verlag Italia. ISBN 978-8-847-01814-3.
+
+
+== External links ==
+The Stanford University Persuasive Technology Lab Archived 2011-03-05 at the Wayback Machine
+The Web Credibility Project
+Persuasive Computers: Perspectives and Research Directions

data/en.wikipedia.org/wiki/Cardinal_tree-0.md

@@ -0,0 +1,18 @@
+---
+title: "Cardinal tree"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Cardinal_tree"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:31:38.992204+00:00"
+instance: "kb-cron"
+---
+
+A cardinal tree (or trie) of degree k, by analogy with cardinal numbers and by opposition with ordinal trees, is a rooted tree in which each node has k positions for an edge to a child. Each node has up to k children and each child of a given node is labeled by a unique integer from the set {1, 2, . . . , k}. For instance, a binary tree is a cardinal tree of degree 2.
+
+
+== See also ==
+Ordinal tree
+
+
+== References ==

data/en.wikipedia.org/wiki/Cartesian_Perceptual_Compression-0.md

@@ -0,0 +1,27 @@
+---
+title: "Cartesian Perceptual Compression"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Cartesian_Perceptual_Compression"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:31:40.224787+00:00"
+instance: "kb-cron"
+---
+
+Cartesian Perceptual Compression (abbreviated CPC, with filename extension .cpc) is a proprietary image file format.  It was designed for high compression of black-and-white raster document imaging for archival scans.
+CPC is lossy, has no lossless mode, and is restricted to bi-tonal images.  The company which controls the patented format claims it is highly effective in the compression of text, black-and-white (halftone) photographs, and line art.  The format is intended for use in the web distribution of legal documents, design plans, and geographical plot maps.
+Viewing and converting documents in the CPC format currently requires the download of proprietary software.  Although viewing CPC documents is free, as is converting CPC images to other formats, conversion to CPC format requires a purchase.
+JSTOR, a United States–based online system for archiving academic journals, converted its online archives to CPC in 1997.  The CPC files are used to reduce storage requirements for its online collection, but are temporarily converted on their servers to GIF for display, and to PDF for printing.  JSTOR still scans to TIFF G4 and considers those files its preservation masters.
+
+
+== See also ==
+Image file formats
+
+
+== References ==
+
+
+== External links ==
+The company's website Additional technical information about the format
+Library of Congress Analysis of format by the LoC.
+RLG DigiNews Vol. 7 No. 2 Comparison of rivals to TIFF for Document Imaging purposes

data/en.wikipedia.org/wiki/Cellular_multiprocessing-0.md

@@ -0,0 +1,24 @@
+---
+title: "Cellular multiprocessing"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Cellular_multiprocessing"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:31:41.586161+00:00"
+instance: "kb-cron"
+---
+
+Cellular multiprocessing is a multiprocessing computing architecture designed initially for Intel central processing units from Unisys, a worldwide information technology consulting company.
+It consists of the partitioning of processors into separate computing environments running different operating systems. Providing up to 32 processors that are crossbar connected to 64GB of memory and 96 PCI cards, a CMP system provides mainframe-like architecture using Intel CPUs. CMP supports Windows NT and Windows 2000 Server, AIX, Novell NetWare and UnixWare and can be run as one large SMP system or multiple systems with variant operating systems.
+There is a concept of creating CPU Partitions in CMPs, e.g. one can create a full partition of 32 processors, Or one can create two partitions of 16 processors each, these two partitions will be visible to the OS installed as two machines. Similarly for 32 processors it is possible to create 32 partitions at max each having a single CPU. Unisys' CMP is the only server architecture to take full advantage of Microsoft's Windows 2000 Datacenter Server operating system's support for 32 processors.
+In case of LINUX/UNIX OS the CMP technology is proven to be very best, whereas in case of Windows 2003 Servers installations, there are certain limits for partitions having number of CPUs, like for a windows 2003 installation the maximum CPU in a partition can only be 4, if more CPUs are assigned severe performance degrade are observed. Even on 8 CPU partition the performance is comparable to the performance of a 2 processors partition.
+A CMP subpod contains four x86 or Itanium CPUs, which connect through a third-level memory cache to the crossbar. Each crossbar supports two subpods, two direct I/O bridges (DIBs) and can connect to four memory storage units (MSUs).
+Unisys is also providing CMP server technology to Compaq, Dell, Hewlett-Packard and ICL, under OEM agreements.
+
+
+== See also ==
+Asymmetric multiprocessing
+Symmetric multiprocessing
+
+
+== References ==

data/en.wikipedia.org/wiki/Cepstral_mean_and_variance_normalization-0.md

@@ -0,0 +1,35 @@
+---
+title: "Cepstral mean and variance normalization"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Cepstral_mean_and_variance_normalization"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:31:42.797762+00:00"
+instance: "kb-cron"
+---
+
+Cepstral mean and variance normalization (CMVN) is a computationally efficient normalization technique for robust speech recognition. The performance of CMVN is known to degrade for short utterances. This is due to insufficient data for parameter estimation and loss of discriminable information as all utterances are forced to have zero mean and unit variance. 
+CMVN minimizes distortion by noise contamination for robust feature extraction by linearly transforming the cepstral coefficients to have the same segmental statistics.  Cepstral Normalization has been effective in the CMU Sphinx for maintaining a high level of recognition accuracy over a wide variety of acoustical environments.
+
+
+== Cepstral Normalization Techniques ==
+There are multiple algorithms that achieve Cepstral Normalization in different ways.  
+
+
+=== Fixed codeword-dependent cepstral normalization (FCDCN) ===
+FCDCN was developed to provide a form of compensation that provides greater recognition accuracy than SDCN but in a more computationally-efficient manner than the CDCN algorithm. The FCDCN algorithm applies an additive correction that depends on the instantaneous SNR of the input (like SDCN), but that can also vary from codeword to codeword (like CDCN).
+
+
+=== Multiple Fixed Codeword-dependent Cepstral Normalization (MFCDCN) ===
+MFCDCN is a simple extension of FCDCN algorithm that does not need environment specific training. In MFCDCN, compensation vectors are pre-computed in parallel for a set of target environments, using the FCDCN algorithm. 
+
+
+=== Incremental Multiple Fixed Codeword-dependent Cepstral Normalization (IMFCDCN) ===
+While environment selection for the compensation vectors of MFCDCN is generally performed on an utterance-by-utterance basis, IMFCFCN improves on it by allowing the classification process to make use of cepstral vectors from previous utterances in a given session.
+
+
+== Cepstral Noise Subtraction ==
+Automatic speech recognition (ASR) describes the steps of transcribing speech utterances represented as acoustic wave forms to written words. As is, CMVN has been used in different applications as this technique has proven to provide better speech recognitions results in different environments. CMVN has the capabilities to reduce differences between test and training data produced by channel distortions and colorizations . CMVN has also been found to be able to reduce differences in feature representation between speakers can also partly reduce the influence of background noise.
+
+
+== References ==

data/en.wikipedia.org/wiki/ClearTalk-0.md

@@ -0,0 +1,26 @@
+---
+title: "ClearTalk"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/ClearTalk"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:31:44.028522+00:00"
+instance: "kb-cron"
+---
+
+ClearTalk is a controlled natural language—a kind of a formal language for expressing information that is designed to be both human-readable (being based on English) and easily processed by a computer.
+Anyone who can read English can immediately read ClearTalk, and the people who write ClearTalk learn to write it while using it. The ClearTalk system itself does most of the training through use: the restrictions are shown by menus and templates and are enforced by immediate syntactic checks. By consistently using ClearTalk for its output, a system reinforces the acceptable syntactic forms.
+It is used by CODE4, the experimental knowledge management software Ikarus, and by a knowledge base management system Fact Guru.
+ClearTalk is easily readable by most people who can read English, and requires very little training to write. Databases of information have been written using ClearTalk by a 9-year old human.
+More than 25,000 facts have been encoded in ClearTalk.
+ClearTalk allows varying degrees of formality or specificity, allowing the author to choose to leave or remove ambiguity.
+ClearTalk was created in 1988 and fell out of use about 2006. It is the oldest controlled natural language with a formal representation.
+
+
+== Citations ==
+
+
+== References ==
+
+
+== Further reading ==

data/en.wikipedia.org/wiki/Cluster-aware_application-0.md

@@ -0,0 +1,24 @@
+---
+title: "Cluster-aware application"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Cluster-aware_application"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:31:45.215291+00:00"
+instance: "kb-cron"
+---
+
+A cluster-aware application is a software application designed to call cluster APIs in order to determine its running state, in case a manual failover is triggered between cluster nodes for planned technical maintenance, or an automatic failover is required, if a computing cluster node encounters hardware or software failure, to maintain business continuity. A cluster-aware application may be capable of failing over LAN or WAN.
+
+
+== Cluster-aware application characteristics ==
+Use TCP/IP to maintain heartbeat between nodes.
+Capable of transaction processing.
+Mirroring cluster information in realtime.
+
+
+== See also ==
+Cluster (computing)
+
+
+== References ==

data/en.wikipedia.org/wiki/CoSy-0.md

@@ -0,0 +1,27 @@
+---
+title: "CoSy"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/CoSy"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:17.609556+00:00"
+instance: "kb-cron"
+---
+
+CoSy, short for Conferencing System, was an early computer conferencing system developed at the University of Guelph.
+The CoS software grew out of an interest in group computer mediated communication systems in 1981 by Dick Mason and John Black. A project was initiated in the Institute of Computer Science to investigate and possibly acquire an asynchronous computer conferencing system, and a small team of Bob McQueen, Alastair Mayer and Peter Jaspers-Fayer undertook the investigation of two existing systems, EIES from New Jersey, and COM from Sweden. It was then decided that developing a new system in-house would be the best path to take.
+A new system started to take shape, written in C and operating under a UNIX operating system on a Digital Equipment Corporation PDP-11 with dial-up telephone ports. Much thought was given to the user interface and group interaction processes, especially as most of the user dial-up connections were originally at very slow 300 bits (30 characters) per second through acoustic modems. The system was gradually introduced to and tested by a small group of users, and eventually made available to other external organizations beginning in 1983.  Licenses to use the Unix version of the software were granted to other sites, mainly universities, and a VMS version was also developed and made available for license. CoSy was selected by Byte to launch their BIX system in 1985    
+In addition to BIX, it was used to implement a similar British system named CIX, as well as numerous other installations such as CompuLink Network.   
+In 1985, the Arkleton Trust, a small independent research charity based in the Highlands of Scotland, worked with the CoSy team at Guelph to incorporate CoSy into the Arkleton Trust's RURTEL, one of the earliest, public-access computer-based communications networks of its kind in Europe.  
+CoSy was also chosen for the Open University's "electronic campus".
+The software was used at the University of Victoria in the Creative Writing department in the 1980s. This exposure to Dave Godfrey led to some rights to the software being later acquired by the British Columbia company SoftWords, who developed it into CoSy400 and added a simple web interface, before losing interest.
+When the BIX system closed down, several former "bixen" approached University of Guelph and SoftWords and obtained the right to release the original version of CoSy under the GPL.  It is now developed as an open source project, and was the basis of the BIX-like NLZero (Noise Level Zero) conferencing service.
+
+
+== References ==
+
+
+== External links ==
+WebCoSy
+CoSy at SourceForge
+NLZ website

data/en.wikipedia.org/wiki/Code_as_data-0.md

@@ -0,0 +1,21 @@
+---
+title: "Code as data"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Code_as_data"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:31:46.392781+00:00"
+instance: "kb-cron"
+---
+
+In computer science, the expression code as data refers to the idea that source code written in a programming language can be manipulated as data, such as a sequence of characters or an abstract syntax tree (AST), and it has an execution semantics only in the context of a given compiler or interpreter. The notion is often used in the context of Lisp-like languages that use S-expressions as their main syntax, as writing programs using nested lists of symbols makes the interpretation of the program as an AST quite transparent (a property known as homoiconicity).
+These ideas are generally used in the context of what is called metaprogramming, writing programs that treat other programs as their data. For example, code-as-data allows the serialization of first-class functions in a portable manner. Another use case is storing a program in a string, which is then processed by a compiler to produce an executable. More often there is a reflection API that exposes the structure of a program as an object within the language, reducing the possibility of creating a malformed program.
+In computational theory, Kleene's second recursion theorem provides a form of code-is-data, by proving that a program can have access to its own source code.
+Code-as-data is also a principle of the Von Neumann architecture, since stored programs and data are both represented as bits in the same memory device. This architecture offers the ability to write self-modifying code. It also opens the security risk of disguising a malicious program as user data and then using an exploit to direct execution to the malicious program.
+
+
+== Data as Code ==
+In declarative programming, the data as code (DaC) principle refers to the idea that an arbitrary data structure can be exposed using a specialized language semantics or API. For example, a list of integers or a string is data, but in languages such as Lisp and Perl, they can be directly entered and evaluated as code. Configuration scripts, domain-specific languages and markup languages are cases where program execution is controlled by data elements that are not clearly sequences of commands.
+
+
+== References ==

data/en.wikipedia.org/wiki/Code_rate-0.md

@@ -0,0 +1,64 @@
+---
+title: "Code rate"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Code_rate"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:31:47.594641+00:00"
+instance: "kb-cron"
+---
+
+In telecommunication and information theory, the code rate (or information rate) of a forward error correction code is the proportion of the data-stream that is useful (non-redundant). That is, if the code rate is 
+  
+    
+      
+        k
+        
+          /
+        
+        n
+      
+    
+    {\displaystyle k/n}
+  
+, for every k bits of useful information, the coder generates a total of n bits of data, of which 
+  
+    
+      
+        n
+        −
+        k
+      
+    
+    {\displaystyle n-k}
+  
+ are redundant. 
+If R is the gross bit rate or data signalling rate (inclusive of redundant error coding), the net bit rate (the useful bit rate exclusive of error correction codes) is 
+  
+    
+      
+        ≤
+        R
+        ⋅
+        k
+        
+          /
+        
+        n
+      
+    
+    {\displaystyle \leq R\cdot k/n}
+  
+. 
+For example: The code rate of a convolutional code will typically be 1⁄2, 2⁄3, 3⁄4, 5⁄6, 7⁄8, etc., corresponding to one redundant bit inserted after every single, second, third, etc., bit. The code rate of the octet oriented Reed Solomon block code denoted RS(204,188) is 188/204, meaning that 204 − 188 = 16 redundant octets (or bytes) are added to each block of 188 octets of useful information. 
+A few error correction codes do not have a fixed code rate—rateless erasure codes.
+Note that bit/s is a more widespread unit of measurement for the information rate, implying that it is synonymous with net bit rate or useful bit rate exclusive of error-correction codes.
+
+
+== See also ==
+Entropy rate
+Information rate
+Punctured code
+
+
+== References ==

data/en.wikipedia.org/wiki/Coded_mark_inversion-0.md

@@ -0,0 +1,26 @@
+---
+title: "Coded mark inversion"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Coded_mark_inversion"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:31:48.778759+00:00"
+instance: "kb-cron"
+---
+
+In telecommunication, coded mark inversion (CMI) is a non-return-to-zero (NRZ) line code. It encodes zero bits as a half bit time of zero followed by a half bit time of one, and while one bits are encoded as a full bit time of a constant level.  The level used for one bits alternates each time one is coded.
+This is vaguely reminiscent of, but quite different from, Miller encoding, which also uses half-bit and full-bit pulses, but additionally uses the half-one/half-zero combination and arranges them so that the signal always spends at least a full bit time at a particular level before transitioning again.
+CMI doubles the bitstream frequency, when compared to its simple NRZ equivalent, but allows easy and reliable clock recovery.
+
+
+== See also ==
+Manchester code
+
+
+== References ==
+ITU-T G.703 (11/2001), Annex A, A.3. Definition of CMI.
+US 4325053, Pierre Le Brozec; Francois Ferret & Pierre Doussoux, "Method and a circuit for decoding a C.M.I. encoded binary signal", issued 1982-04-13 
+
+
+== External links ==
+ Media related to Coded mark inversion at Wikimedia Commons

data/en.wikipedia.org/wiki/Collision_avoidance_(networking)-0.md

@@ -0,0 +1,28 @@
+---
+title: "Collision avoidance (networking)"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Collision_avoidance_(networking)"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:31:49.967815+00:00"
+instance: "kb-cron"
+---
+
+In computer networking and telecommunication, collision-avoidance methods try to avoid resource contention by attempting to avoid simultaneous attempts to access the same resource.
+Collision-avoidance methods include prior scheduling of timeslots, carrier-detection schemes, randomized access times, and exponential backoff after collision detection.  In addition to the collision-avoidance methods mentioned, another important technique commonly used in computer networking and telecommunication to avoid resource contention is the implementation of protocols such as Carrier Sense Multiple Access with Collision Detection (CSMA/CD) and Carrier Sense Multiple Access with Collision Avoidance (CSMA/CA).
+CSMA/CD is a protocol used in Ethernet networks to regulate access to the network medium. Before transmitting data, a device using CSMA/CD first listens to the network to check if it is idle. If the network is busy, the device waits for a random amount of time before attempting to transmit again. If a collision is detected during transmission, the devices involved stop sending data and implement a backoff algorithm to avoid further collisions.
+CSMA/CA is a protocol commonly used in wireless networks to avoid collisions. With CSMA/CA, devices listen to the wireless channel before transmitting data. If the channel is clear, the device can proceed with transmission. If the channel is busy, the device waits for a random amount of time before attempting to transmit. Additionally, devices may use Request to Send (RTS) and Clear to Send (CTS) messages to reserve the channel before transmitting data, further reducing the likelihood of collisions.
+These protocols and methods are essential in ensuring efficient and reliable communication in networked environments by minimizing the impact of collisions and resource contention, ultimately improving the overall performance and scalability of the network.
+
+
+== See also ==
+Carrier sense multiple access with collision avoidance
+Polling
+Collision domain
+
+
+== References ==
+
+
+== External links ==
+Lenzini, L.; Luise, M.; Reggiannini, R. (June 2001). "CRDA: A Collision Resolution and Dynamic Allocation MAC Protocol to Integrate Date and Voice in Wireless Networks". IEEE Journal on Selected Areas in Communications. 19 (6). IEEE Communications Society: 1153–1163. doi:10.1109/49.926371. ISSN 0733-8716.

data/en.wikipedia.org/wiki/Common_Business_Communication_Language-0.md

@@ -0,0 +1,18 @@
+---
+title: "Common Business Communication Language"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Common_Business_Communication_Language"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:31:51.147438+00:00"
+instance: "kb-cron"
+---
+
+The Common Business Communication Language (CBCL) is a communications language proposed by John McCarthy that foreshadowed much of XML. The language consists of a basic framework of hierarchical markup derived from S-expressions, coupled with some general principles about use and extensibility. Although written in 1975, the proposal was not published until 1982, and to this day remains relatively obscure.
+
+
+== References ==
+
+
+== External links ==
+John McCarthy's original CBCL proposal, webified and with a 1998 appendix considering some of the then-current work going on with XML and other communications languages.

data/en.wikipedia.org/wiki/Compile_farm-0.md

@@ -0,0 +1,28 @@
+---
+title: "Compile farm"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Compile_farm"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:31:52.399345+00:00"
+instance: "kb-cron"
+---
+
+A compile farm is a server farm, a collection of one or more servers, which has been set up to compile computer programs remotely for various reasons. Uses of a compile farm include:
+
+Cross-platform development: When writing software that runs on multiple processor architectures and operating systems, it can be infeasible for each developer to have their own machine for each architecture — for example, one platform might have an expensive or obscure type of CPU.  In this scenario, a compile farm is useful as a tool for developers to build and test their software on a shared server running the target operating system and CPU.  Compile farms may be preferable to cross-compilation as cross compilers are often complicated to configure, and in some cases compilation is only possible on the target, making cross-compilation impossible.
+Cross-platform continuous integration testing: in this scenario, each server has a different processor architecture or runs a different operating system; scripts automatically build the latest version of a source tree from a version control repository.  One of the difficulties of cross-platform development is that a programmer may unintentionally introduce an error that causes the software to stop functioning on a different CPU/OS platform from the one they are using.  By using a cross-platform compile farm, such errors can be identified and fixed.
+Distributed compilation: Building software packages typically requires operations that can be run in parallel (for example, compiling individual source code files).  By using a compile farm, these operations can be run in parallel on separate machines.  An example of a program which can be used to do this is distcc.
+One example of a compile farm was the service provided by SourceForge until 2006.  The SourceForge compile farm was composed of twelve machines of various computer architectures running a variety of operating systems, and was intended to allow developers to test and use their programs on a variety of platforms before releasing them to the public.  After a power spike destroyed several of the machines it became non-operational some time in 2006, and was officially discontinued in February 2007.
+Other examples are:
+
+GCC Compile Farm https://gcc.gnu.org/wiki/CompileFarm
+OpenSUSE Build Service
+FreeBSD reports service which lets package maintainers test their own changes on a variety of versions and architectures.
+Launchpad Build Farm https://launchpad.net/builders
+Mozilla has a build farm, but it is not public https://wiki.mozilla.org/ReleaseEngineering
+Debian has a build farm https://buildd.debian.org/
+OpenCSW build farm for Solaris x86 and Sparc
+
+
+== References ==

data/en.wikipedia.org/wiki/Compile_time-0.md

@@ -0,0 +1,24 @@
+---
+title: "Compile time"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Compile_time"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:31:53.599704+00:00"
+instance: "kb-cron"
+---
+
+In computing, compile time is the period of time when a compiler processes source code into other code that is more readily executable – typically object code or byte code. Compile time is a phase in the operational life cycle of a program as it transitions from development to execution. The length of time it takes to compile is usually referred to as compilation time although compile time might also be used.
+Compile time can be subdivided by the phases of a compiler. Most compilers have at least the following phases: syntax analysis, semantic analysis, and code generation. Many compilers include one or more optimization phases. For example, each constant expressions might be evaluated via compile-time execution to produce a value that results in improved runtime performance.
+Properties of a program that can be determined at compile time include range-checks (e.g., proving that an array index will not exceed the array bounds), deadlock freedom in concurrent languages, or timings (e.g., proving that a sequence of code takes no more than an allocated amount of time). For statically-typed languages such as C++, Java or Rust, types are checked at compile time to ensure type safety.
+Compiling is typically part of a build process (at build time). A build may also include linking (at link time). Run time is the duration when the program is running.
+Often, compilation occurs as a separate step before running a program. But with dynamic compilation, transformation to machine language happens as part of the process of running it – intertwining run time and compile time. Often this is split into two distinct processes: a build-time process that converts source code to an intermediate representation (IR) and a run-time process that converts the IR to machine code.
+
+
+== See also ==
+Ahead-of-time compilation – Computer code compilation strategy
+Just-in-time compilation – Compiling bytecode to machine code at runtime
+Type system – Computer science concept
+
+
+== References ==

data/en.wikipedia.org/wiki/Computational_history-0.md

@@ -0,0 +1,17 @@
+---
+title: "Computational history"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Computational_history"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:31:54.775771+00:00"
+instance: "kb-cron"
+---
+
+Computational History (not to be confused with computation history), sometimes also called Histoinformatics, is a multidisciplinary field that studies history through machine learning and other data-driven, computational approaches.
+
+
+== See also ==
+
+
+== References ==

data/en.wikipedia.org/wiki/Computer_Aided_Verification-0.md

@@ -0,0 +1,27 @@
+---
+title: "Computer Aided Verification"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Computer_Aided_Verification"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:31:55.990307+00:00"
+instance: "kb-cron"
+---
+
+In computer science, the International Conference on Computer-Aided Verification (CAV) is an annual academic conference on the theory and practice of computer-aided formal analysis of software and hardware systems, broadly known as formal methods. Among the important results originally published in CAV are techniques in model checking, such as Counterexample-Guided Abstraction Refinement and partial order reduction. It is often ranked among the top conferences in computer science. 
+The first CAV was held in 1989 in Grenoble, France. The CAV proceedings (1989-present) are published by Springer Science+Business Media. They have been open access since 2018. The annual CAV Award was established in 2008. The list of recipients and citations can be found at https://i-cav.org/cav-award/.
+
+
+== See also ==
+List of computer science conferences
+Symposium on Logic in Computer Science
+European Joint Conferences on Theory and Practice of Software
+
+
+== References ==
+
+
+== External links ==
+Official website 
+bibliography for CAV at DBLP
+Conference proceedings

data/en.wikipedia.org/wiki/Computer_Russification-0.md

@@ -0,0 +1,38 @@
+---
+title: "Computer Russification"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Computer_Russification"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:31:57.125354+00:00"
+instance: "kb-cron"
+---
+
+In computing, Russification involves the localization of computers and software, allowing the user interface of a computer and its software to communicate in the Russian language using Cyrillic script.
+Problems associated with Russification before the advent of Unicode included the absence of a single character-encoding standard for Cyrillic.
+
+
+== History of the MS-DOS Russification ==
+The first official Russification of MS-DOS was carried out for MS-DOS 4.01 in 1989/1990, released on 9 April 1990 (1990-04-09). In Microsoft, the Russification project manager and one of its main developers was Nikolai Lyubovny (Николай Любовный). A Russian version of MS-DOS 5.0 was also developed in 1991, released on 9 August 1991 (1991-08-09). Based on an initiative of Microsoft Germany in March 1991, derivates of the Russian MS-DOS 5.0 drivers used for keyboard, display and printer localization support (DISPLAY.SYS, EGS.CPI, EGA2.CPI, KEYB.COM, KEYBOARD.SYS, MSPRINT.SYS, COUNTRY.SYS, ALPHA.EXE) could also be purchased separately (with English messages) as part of Microsoft's AlphabetPlus kit. This enabled English issues of MS-DOS 3.3, 4.01 and 5.0 to be set up for Eastern European countries like Czechoslovakia, Poland, Hungary, Yugoslavia, Romania and Bulgaria.
+
+
+== Russification of Microsoft Windows ==
+A comprehensive instruction set for computer Russification is maintained by Paul Gorodyansky. It is mirrored in many places and recommended by the U.S. Library of Congress.
+
+
+== See also ==
+Cyrillic script in Unicode
+Cyrillization
+GOST 10859
+Mojibake
+PTS-DOS
+Romanization of Russian
+
+
+== References ==
+
+
+== External links ==
+Modern Online (Virtual) Keyboard for Russian (not just alphabet order)
+Online Keyboard for Russian
+Virtual Russian Online Keyboard with Spellcheck

data/en.wikipedia.org/wiki/Computer_Science_Tripos-0.md

@@ -0,0 +1,20 @@
+---
+title: "Computer Science Tripos"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Computer_Science_Tripos"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:31:58.336284+00:00"
+instance: "kb-cron"
+---
+
+The Computer Science Tripos (CST) is the undergraduate course in computer science offered by the University of Cambridge Computer Laboratory. It evolved out of the Diploma in Computer Science, the world's first taught course in computer science, which started in 1953.  Successful candidates are awarded a Bachelor of Arts (BA) honours degree after three years or, a combined BA + Master of Engineering (MEng) honours degree after four years of study, though admission to the fourth year is usually contingent on attaining a first-class result in the third year.
+
+
+== Notable alumni ==
+Aubrey de Grey
+Demis Hassabis
+Simon Tatham
+
+
+== References ==

data/en.wikipedia.org/wiki/Computing_with_words_and_perceptions-0.md

@@ -0,0 +1,24 @@
+---
+title: "Computing with words and perceptions"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Computing_with_words_and_perceptions"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:31:59.537633+00:00"
+instance: "kb-cron"
+---
+
+In computing with words and perceptions (CWP), the objects of computation are words, perceptions, and propositions drawn from a natural language.  The central theme of CWP is the concept of a generalised constraint.  The meaning of a proposition is expressed as a generalised constraint.
+CWP is a necessary tool when the available information is perception-based or not precise enough to use numbers.
+
+
+== See also ==
+Fuzzy set
+Lotfi Zadeh
+Perceptual computing
+Type-2 fuzzy sets and systems
+
+
+== References ==
+
+L. A. Zadeh, “Fuzzy logic = computing with words,” IEEE Trans. on Fuzzy Systems, vol. 4, pp. 103-111, 1996.

data/en.wikipedia.org/wiki/Concurrency_pattern-0.md

@@ -0,0 +1,49 @@
+---
+title: "Concurrency pattern"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Concurrency_pattern"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:00.775692+00:00"
+instance: "kb-cron"
+---
+
+A concurrency pattern is a software  design pattern that supports concurrent processing.
+
+
+== Examples ==
+Examples include:
+
+Active object
+Balking pattern
+Barrier
+Double-checked locking
+Guarded suspension
+Monitor object
+Nuclear reaction
+Reactor pattern
+Readers–writer lock
+Scheduler pattern
+Thread pool pattern
+Thread-local storage
+
+
+== See also ==
+Behavioral pattern
+Creational pattern
+Design Patterns
+Structural pattern
+
+
+== References ==
+
+
+== External links ==
+ScaleConf Presentation about concurrency patterns
+GopherCon Rethinking Classical Concurrency Patterns slides
+GoWiki: Learn Concurrency
+Recordings about concurrency patterns from Software Engineering Radio:
+
+Episode 12: Concurrency Pt. 1
+Episode 19: Concurrency Pt. 2
+Episode 29: Concurrency Pt. 3

data/en.wikipedia.org/wiki/Concurrency_semantics-0.md

@@ -0,0 +1,15 @@
+---
+title: "Concurrency semantics"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Concurrency_semantics"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:01.957195+00:00"
+instance: "kb-cron"
+---
+
+In computer science, concurrency semantics is a way to give meaning to concurrent systems in a mathematically rigorous way. Concurrency semantics is often based on mathematical theories of concurrency such as various process calculi, the actor model, or Petri nets.
+A more detailed account of concurrency semantics is given here: Concurrency (computer science).
+
+
+== References ==

data/en.wikipedia.org/wiki/Conference_on_Automated_Deduction-0.md

@@ -0,0 +1,20 @@
+---
+title: "Conference on Automated Deduction"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Conference_on_Automated_Deduction"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:03.171018+00:00"
+instance: "kb-cron"
+---
+
+The Conference on Automated Deduction (CADE) is the premier academic conference on automated deduction and related fields. The first CADE was organized in 1974 at the Argonne National Laboratory near Chicago. Most CADE meetings have been held in Europe and the United States. However, conferences have been held all over the world. Since 1996, CADE has been held yearly.  In 2001, CADE was, for the first time, merged into the International Joint Conference on Automated Reasoning (IJCAR). This has been repeated biannually since 2004.
+In 1996, CADE Inc. was formed as a non-profit sub-corporation of the Association for Automated Reasoning to organize the formerly individually organized conferences.
+
+
+== References ==
+
+
+== External links ==
+Official website, CADE
+Official website, AAR

data/en.wikipedia.org/wiki/Configurable_modularity-0.md

@@ -0,0 +1,18 @@
+---
+title: "Configurable modularity"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Configurable_modularity"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:04.389123+00:00"
+instance: "kb-cron"
+---
+
+Configurable modularity is a term coined by Raoul de Campo of IBM Research and later expanded on by Nate Edwards of the same organization, denoting the ability to reuse independent components by changing their interconnections, but not their internals.  In Edwards' view this characterizes all successful reuse systems, and indeed all systems which can be described as "engineered".
+
+
+== See also ==
+Flow-Based Programming
+
+
+== References ==

data/en.wikipedia.org/wiki/Confusion_network-0.md

@@ -0,0 +1,14 @@
+---
+title: "Confusion network"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Confusion_network"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:05.535583+00:00"
+instance: "kb-cron"
+---
+
+A confusion network (sometimes called a word confusion network or informally known as a sausage) is a natural language processing method that combines outputs from multiple automatic speech recognition or machine translation systems. Confusion networks are simple linear directed acyclic graphs with the property that each a path from the start node to the end node goes through all the other nodes. The set of words represented by edges between two nodes is called a confusion set. In machine translation, the defining characteristic of confusion networks is that they allow multiple ambiguous inputs, deferring committal translation decisions until later stages of processing. This approach is used in the open source machine translation software Moses and the proprietary translation API in IBM Bluemix Watson.
+
+
+== References ==

data/en.wikipedia.org/wiki/Connection_string-0.md

@@ -0,0 +1,36 @@
+---
+title: "Connection string"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Connection_string"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:06.840584+00:00"
+instance: "kb-cron"
+---
+
+In computing, a connection string is a string that specifies information about a data source and the means of connecting to it. It is passed in code to an underlying driver or provider in order to initiate the connection. Whilst commonly used for a database connection, the data source could also be a spreadsheet or text file.
+The connection string may include attributes such as the name of the driver, server and database, as well as security information such as user name and password.
+
+
+== Examples ==
+This example shows a PostgreSQL connection string for connecting to wikipedia.com with SSL and a connection timeout of 180 seconds:
+
+DRIVER={PostgreSQL Unicode};SERVER=www.wikipedia.com;SSL=true;SSLMode=require;DATABASE=wiki;UID=wikiuser;Connect Timeout=180;PWD=ashiknoor
+
+Users of Oracle databases can specify connection strings:
+
+on the command line (as in: sqlplus scott/tiger@connection_string )
+via environment variables ($TWO_TASK in Unix-like environments; %TWO_TASK% in Microsoft Windows environments)
+in local configuration files (such as the default $ORACLE_HOME/network/admin.tnsnames.ora)
+in LDAP-capable directory services
+
+
+== See also ==
+Data source name
+
+
+== References ==
+
+
+== External links ==
+"Connection strings in SQL Server 2017". Retrieved 15 June 2019.

data/en.wikipedia.org/wiki/Constraint_(information_theory)-0.md

@@ -0,0 +1,21 @@
+---
+title: "Constraint (information theory)"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Constraint_(information_theory)"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:08.039253+00:00"
+instance: "kb-cron"
+---
+
+Constraint in information theory is the degree of statistical dependence between or among variables.
+Garner provides a thorough discussion of various forms of constraint (internal constraint, external constraint, total constraint) with application to pattern recognition and psychology.
+
+
+== See also ==
+Mutual Information
+Total Correlation
+Interaction information
+
+
+== References ==

data/en.wikipedia.org/wiki/Context-adaptive_variable-length_coding-0.md

@@ -0,0 +1,46 @@
+---
+title: "Context-adaptive variable-length coding"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Context-adaptive_variable-length_coding"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:10.450545+00:00"
+instance: "kb-cron"
+---
+
+Context-adaptive variable-length coding (CAVLC) is a form of entropy coding used in H.264/MPEG-4 AVC video encoding. It is an inherently lossless compression technique, like almost all entropy-coders. In H.264/MPEG-4 AVC, it is used to encode residual, zig-zag order, blocks of transform coefficients. It is an alternative to context-adaptive binary arithmetic coding (CABAC). CAVLC requires considerably less processing to decode than CABAC, although it does not compress the data quite as effectively. CAVLC is supported in all H.264 profiles, unlike CABAC which is not supported in Baseline and Extended profiles.
+CAVLC is used to encode residual, zig-zag ordered 4×4 (and 2×2) blocks of transform coefficients. CAVLC is designed to take advantage of several characteristics of quantized 4×4 blocks:
+
+After prediction, transformation and quantization, blocks are typically sparse (containing mostly zeros).
+The highest non-zero coefficients after zig-zag scan are often sequences of +/− 1. CAVLC signals the number of high-frequency +/−1 coefficients in a compact way.
+The number of non-zero coefficients in neighbouring blocks is correlated. The number of coefficients is encoded using a look-up table; the choice of look-up table depends on the number of non-zero coefficients in neighbouring blocks.
+The level (magnitude) of non-zero coefficients tends to be higher at the start of the reordered array (near the DC coefficient) and lower towards the higher frequencies. CAVLC takes advantage of this by adapting the choice of VLC look-up table for the "level" parameter depending on recently coded level magnitudes.
+
+
+== Coded elements ==
+Parameters that required to be encoded and transmitted include the following table:
+
+
+== CAVLC examples ==
+
+In all following examples, we assume that table Num-VLC0 is used to encode coeff_token.
+
+0, 3, 0, 1, −1, −1, 0, 1, 0…
+TotalCoeffs = 5 (indexed from highest frequency [4] to lowest frequency [0])
+TotalZeros = 3
+T1s = 3 (in fact there are 4 trailing ones but only 3 can be encoded as a "special case")
+Encoding:
+The transmitted bitstream for this block is 000010001110010111101101.
+Decoding:
+The output array is "built up" from the decoded values as shown below. Values added to the output array at each stage are underlined.
+The decoder has inserted two zeros; however, TotalZeros is equal to 3 and so another 1 zero is inserted before the lowest coefficient, making the final output array: 0, 3, 0, 1, −1, −1, 0, 1
+
+
+== See also ==
+H.264 (entropy coding)
+Data compression
+Lossless compression
+
+
+== References ==
+Richardson, Iain (August 28, 2011). "H.264 / AVC Context Adaptive Variable Length Coding" (PDF). Vcodex. Retrieved 17 November 2024.

data/en.wikipedia.org/wiki/Context_tree_weighting-0.md

@@ -0,0 +1,23 @@
+---
+title: "Context tree weighting"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Context_tree_weighting"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:09.255560+00:00"
+instance: "kb-cron"
+---
+
+The context tree weighting method (CTW) is a lossless compression and prediction algorithm by Willems, Shtarkov & Tjalkens 1995. The CTW algorithm is among the very few such algorithms that offer both theoretical guarantees and good practical performance (see, e.g. Begleiter, El-Yaniv & Yona 2004).
+The CTW algorithm is an “ensemble method”, mixing the predictions of many underlying variable order Markov models, where each such model is constructed using zero-order conditional probability estimators.
+
+
+== References ==
+Willems; Shtarkov; Tjalkens (1995), "The Context-Tree Weighting Method: Basic Properties", IEEE Transactions on Information Theory, 41 (3), IEEE Transactions on Information Theory: 653–664, Bibcode:1995ITIT...41..653W, doi:10.1109/18.382012
+Willems; Shtarkov; Tjalkens (1997), Reflections on "The Context-Tree Weighting Method: Basic Properties", vol. 47, IEEE Information Theory Society Newsletter, CiteSeerX 10.1.1.109.1872{{citation}}:  CS1 maint: location missing publisher (link)
+Begleiter; El-Yaniv; Yona (2004), "On Prediction Using Variable Order Markov Models", Journal of Artificial Intelligence Research, 22, Journal of Artificial Intelligence Research: 385–421, arXiv:1107.0051, doi:10.1613/jair.1491, S2CID 47180476
+
+
+== External links ==
+Relevant CTW papers and implementations
+CTW Official Homepage

data/en.wikipedia.org/wiki/Contextualization_(computer_science)-0.md

@@ -0,0 +1,30 @@
+---
+title: "Contextualization (computer science)"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Contextualization_(computer_science)"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:11.665298+00:00"
+instance: "kb-cron"
+---
+
+In computer science, contextualization is the process of identifying the data relevant to an entity (e.g., a person or a city) based on the entity's contextual information.
+
+
+== Definition ==
+Context or contextual information is any information about any entity that can be used to effectively reduce the amount of reasoning required (via filtering, aggregation, and inference) for decision making within the scope of a specific application. Contextualisation is then the process of identifying the data relevant to an entity based on the entity's contextual information. Contextualisation excludes irrelevant data from consideration and has the potential to reduce data from several aspects including volume, velocity, and variety in large-scale data intensive applications (Yavari et al.).
+
+
+== Usage ==
+The main usage of "contextualisation" is in improving the process of data:
+
+Reduce the amount of data: Contextualisation has the potential to reduce the amount of data based on the interests from applications/services/users. Contextualisation can improve the scalability and efficiency of data process, query, delivery by excluding irrelevant data.
+As an example, ConTaaS facilitates contextualisation of the data for IoT applications and could improve the processing for large-scale IoT applications from various Big Data aspects including volume, velocity, and variety.
+
+
+== Example domains ==
+Object-oriented programming: Contextualization consists, at object creation time, to provide adequate initialization parameters to a class constructor.
+Virtualization: Contextualization permits, at the end of VM instantiation, to set or override VM data having unknown or default values at the time of creation of the Live CD, typically hostname, IP address, .ssh/authorized_keys, ...
+
+
+== References ==

data/en.wikipedia.org/wiki/Cooperative_distributed_problem_solving-0.md

@@ -0,0 +1,36 @@
+---
+title: "Cooperative distributed problem solving"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Cooperative_distributed_problem_solving"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:12.881685+00:00"
+instance: "kb-cron"
+---
+
+In computing cooperative distributed problem solving is a network of semi-autonomous processing nodes working together to solve a problem, typically in a multi-agent system. That is concerned with the investigation of problem subdivision, sub-problem distribution, results synthesis, optimisation of problem solver coherence and co-ordination. It is closely related to distributed constraint programming and distributed constraint optimization; see the links below.
+
+
+== Aspects of CDPS ==
+Neither global control or global data storage – no individual CDPS problem solver (agent) has sufficient information to solve the entire problem.
+Control and data are distributed
+Communication is slower than computation, therefore:
+Loose coupling between problem solvers
+Efficient protocols (not too much communication overhead)
+problems should be modular, coarse grained
+Any unique node is a potential bottleneck
+Organised behaviour is hard to guarantee since no one node has the complete picture
+
+
+== See also ==
+Multiscale decision making
+Distributed constraint optimization
+Distributed artificial intelligence
+Multi-agent planning
+
+
+== Some relevant books ==
+Faltings, Boi (2006). "Distributed Constraint Programming". In Rossi, Francesca; van Beek, Peter; Walsh, Toby (eds.). Handbook of Constraint Programming. Elsevier. ISBN 978-0-444-52726-4. Archived from the original on 2012-10-04. Retrieved 2009-01-04. A chapter in an edited book.
+Meisels, Amnon (2008). Distributed Search by Constrained Agents. Springer. ISBN 978-1-84800-040-7.
+Shoham, Yoav; Leyton-Brown, Kevin (2009). Multiagent Systems: Algorithmic, Game-Theoretic, and Logical Foundations. New York: Cambridge University Press. ISBN 978-0-521-89943-7. See Chapters 1 and 2; downloadable free online.
+Yokoo, Makoto (2001). Distributed constraint satisfaction: Foundations of cooperation in multi-agent systems. Springer. ISBN 978-3-540-67596-9.

data/en.wikipedia.org/wiki/Coset_leader-0.md

@@ -0,0 +1,16 @@
+---
+title: "Coset leader"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Coset_leader"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:14.051533+00:00"
+instance: "kb-cron"
+---
+
+In coding theory, a coset leader is a word of minimum weight in any particular coset - that is, a word with the lowest amount of non-zero entries. Sometimes there are several words of equal minimum weight in a coset, and in that case, any one of those words may be chosen to be the coset leader.
+Coset leaders are used in the construction of a standard array for a linear code, which can then be used to decode received vectors. For a received vector y, the decoded message is y - e, where e is the coset leader of y. Coset leaders can also be used to construct a fast decoding strategy. For each coset leader u we calculate the syndrome uH′. When we receive v we evaluate vH′ and find the matching syndrome. The corresponding coset leader is the most likely error pattern and we assume that v+u was the codeword sent.
+
+
+== References ==
+Hill, Raymond (1986). A First Course in Coding Theory. Oxford Applied Mathematics and Computing Science series. Oxford University Press. ISBN 978-0-19-853803-5.

data/en.wikipedia.org/wiki/Cost_efficiency-0.md

@@ -0,0 +1,57 @@
+---
+title: "Cost efficiency"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Cost_efficiency"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:16.418958+00:00"
+instance: "kb-cron"
+---
+
+Cost efficiency (or cost optimality), in the context of parallel computer algorithms, refers to a measure of how effectively parallel computing can be used to solve a particular problem. A parallel algorithm is considered cost efficient if its asymptotic running time multiplied by the number of processing units involved in the computation is comparable to the running time of the best sequential algorithm.
+For example, an algorithm that can be solved in 
+  
+    
+      
+        O
+        (
+        n
+        )
+      
+    
+    {\displaystyle O(n)}
+  
+ time using the best known sequential algorithm and 
+  
+    
+      
+        O
+        
+          (
+          
+            
+              n
+              p
+            
+          
+          )
+        
+      
+    
+    {\displaystyle O\left({\frac {n}{p}}\right)}
+  
+ in a parallel computer with 
+  
+    
+      
+        p
+      
+    
+    {\displaystyle p}
+  
+ processors will be considered cost efficient.
+Cost efficiency also has applications to human services.
+
+
+== References ==
+Advanced Computer Architectures: A Design Space Approach, D. Sima, T. Fountain and P. Kacsuk, Addison-Wesley, 1997.

data/en.wikipedia.org/wiki/Counting_hierarchy-0.md

@@ -0,0 +1,26 @@
+---
+title: "Counting hierarchy"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Counting_hierarchy"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:19.950193+00:00"
+instance: "kb-cron"
+---
+
+In complexity theory, the counting hierarchy is a hierarchy of complexity classes. It is analogous to the polynomial hierarchy, but with NP replaced with PP. It was defined in 1986 by Klaus Wagner.
+More precisely, the zero-th level is C0P = P, and the (n+1)-th level is Cn+1P = PPCnP (i.e., PP with oracle Cn). Thus:
+
+C0P = P
+C1P = PP
+C2P = PPPP
+C3P = PPPPPP
+...
+The counting hierarchy is contained within PSPACE. By Toda's theorem, the polynomial hierarchy PH is entirely contained in PPP, and therefore in C2P = PPPP.
+
+
+== References ==
+
+
+== Further reading ==
+Torán, Jacobo (1991). "Complexity classes defined by counting quantifiers". Journal of the ACM. 38 (3): 753–774. doi:10.1145/116825.116858. MR 1125929.

data/en.wikipedia.org/wiki/Critical_security_parameter-0.md

@@ -0,0 +1,14 @@
+---
+title: "Critical security parameter"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Critical_security_parameter"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:22.385353+00:00"
+instance: "kb-cron"
+---
+
+In cryptography, a critical security parameter (CSP) is information that is either user or system defined and is used to operate a cryptography module in processing encryption functions including cryptographic keys and authentication data, such as passwords, the disclosure or modification of which can compromise the security of a cryptographic module or the security of the information protected by the module.
+
+
+== References ==

data/en.wikipedia.org/wiki/Cyberith_Virtualizer-0.md

@@ -0,0 +1,37 @@
+---
+title: "Cyberith Virtualizer"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Cyberith_Virtualizer"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:24.814118+00:00"
+instance: "kb-cron"
+---
+
+The Virtualizer (or Cyberith Virtualizer) is a series of omnidirectional treadmills for virtual reality applications. The treadmills have integrated sensors for motion detection of the user. The products are being developed, manufactured and sold by the Austrian company Cyberith GmbH.
+
+
+== History ==
+The idea was born in 2012 by Tuncay Cakmak. During his studies at the Technical University of Vienna he started testing and developing the first prototypes. In 2013 he founded Cyberith and formed a team for further development of the device. He demonstrated the device at different exhibitions in Europe and shared the progress with the community through the Cyberith YouTube channel. A kickstarter campaign started on 23. of July 2014 and in the first 24 hours they made more than 50% of their pledged goal of 250 000 $.
+The campaign was successfully funded, ending at 361 452 $ from 577 backers, however the delivery of the Kickstarter rewards has been delayed beyond the initial estimate without the company providing an updated estimated delivery date. 
+After the initial crowdfunding on Kickstarter, the company started focusing on commercial use of the Virtualizer products and launched the first generation Virtualizer VR Treadmill in 2016 exclusively to commercial customers. 
+According to unconfirmed rumors, the company has been sued by one of its Kickstarter backers. These rumors suggest that the claim of the backer has been rejected by the court.
+The second generation Virtualizer was launched for business customers in March 2019 with an implemented motion platform.
+
+
+== Functional principle ==
+The Virtualizer enables motion by the principle of low friction. The body is fixed in a rotatable ring that can be moved vertically. In combination with a head-mounted display it allows to move, run, jump or crouch in virtual worlds. The products don't require to wear any special kind of shoes. Instead, textile overshoes are used, that are worn above regular shoes.
+The second generation Virtualizer uses a 2 DOF (Degrees of Freedom) motion platform to actively support the walking movement of a user. For walking forwards, the platform inclines in front of the user, so that the feet glide back more easily due to the support of gravity. When a user rotates or starts to walk backwards, the inclination of the platform follows these movements to continuously support gliding of the feet through gravity. The company claims this motorized system would improve the gait and make walking easier.
+
+
+== See also ==
+Haptic suit
+Virtuix Omni
+Wizdish ROVR
+
+
+== External links ==
+Official website
+
+
+== References ==

data/en.wikipedia.org/wiki/Cyclic_language-0.md

@@ -0,0 +1,30 @@
+---
+title: "Cyclic language"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Cyclic_language"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:26.009151+00:00"
+instance: "kb-cron"
+---
+
+In computer science, more particularly in formal language theory, a cyclic language is a set of strings that is closed with respect to repetition, root, and cyclic shift.
+
+
+== Definition ==
+If A is a set of symbols, and A* is the set of all strings built from symbols in A, then a string set L ⊆ A* is called a formal language over the alphabet A.
+The language L is called cyclic if
+
+∀w∈A*. ∀n>0. w ∈ L ⇔ wn ∈ L, and
+∀v,w∈A*. vw ∈ L ⇔ wv ∈ L,
+where wn denotes the n-fold repetition of the string w, and vw denotes the concatenation of the strings v and w.
+
+
+== Examples ==
+For example, using the alphabet A = {a, b }, the language
+
+is cyclic, but not regular.
+However, L is context-free, since M = { an1bn1 an2bn2 ... ank bnk : ni ≥ 0 } is, and context-free languages are closed under circular shift; L is obtained as circular shift of M.
+
+
+== References ==

data/en.wikipedia.org/wiki/DUAL_(cognitive_architecture)-0.md

@@ -0,0 +1,18 @@
+---
+title: "DUAL (cognitive architecture)"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/DUAL_(cognitive_architecture)"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:56.269850+00:00"
+instance: "kb-cron"
+---
+
+DUAL is a general cognitive architecture integrating the connectionist and symbolic approaches at the micro level. DUAL is based on decentralized representation and emergent computation. It was inspired by the Society of Mind idea proposed by Marvin Minsky, but departs from the initial proposal in many ways. Computations in DUAL emerge from the interaction of many micro-agents, each of which is a hybrid symbolic/connectionist device. The agents exchange messages and activation via links that can be learned and modified, they form coalitions which collectively represent concepts, episodes, and facts. 
+Several models have been developed on the basis of DUAL. These include: AMBR (a model of analogy-making and memory), JUDGEMAP (a model of judgment), PEAN (a model of perception), etc.
+DUAL is developed by a team at the New Bulgarian University led by Boicho Kokinov. The second version was co-authored by Alexander Petrov. The third version is co-authored by Georgi Petkov and Ivan Vankov.
+
+
+== External links ==
+Official website
+[1]

data/en.wikipedia.org/wiki/Data_binding-0.md

@@ -0,0 +1,62 @@
+---
+title: "Data binding"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Data_binding"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:27.151522+00:00"
+instance: "kb-cron"
+---
+
+In computer programming, data-binding is a general technique that binds data sources from the provider and consumer together and synchronizes them. This is usually done with two data/information sources with different languages, as in XML data binding and UI data binding. In UI data binding, data and information objects of the same language, but different logic function are bound together (e.g., Java UI elements to Java objects).
+In a data binding process, each data change is reflected automatically by the elements that are bound to the data. The term data binding is also used in cases where an outer representation of data in an element changes, and the underlying data is automatically updated to reflect this change. As an example, a change in a TextBox element could modify the underlying data value.
+
+
+== Data binding frameworks and tools ==
+List of examples of data binding frameworks and tools for different programming languages:
+
+
+=== C# .NET ===
+Windows Presentation Foundation (WPF)
+Blazor
+Windows Forms
+MAUI
+
+
+=== Delphi ===
+DSharp third-party data binding tool
+OpenWire Visual Live Binding—third-party visual data binding tool
+LiveBindings
+
+
+=== Java ===
+Google Web Toolkit
+JavaFX
+Eclipse
+
+
+=== JavaScript ===
+
+
+=== Objective-C ===
+AKABeacon iOS Data Binding framework
+
+
+=== Swift ===
+SwiftUI
+
+
+=== Scala ===
+Binding.scala
+
+
+== See also ==
+XML data binding
+UI data binding
+
+
+== References ==
+
+
+== Further reading ==
+Noyes, Brian (12 January 2006). Data Binding with Windows Forms 2.0: Programming Smart Client Data Applications with .NET. Pearson Education. ISBN 978-0-321-63010-0.

data/en.wikipedia.org/wiki/Data_drilling-0.md

@@ -0,0 +1,87 @@
+---
+title: "Data drilling"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Data_drilling"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:28.342668+00:00"
+instance: "kb-cron"
+---
+
+Data drilling (also drilldown) refers to any of various operations and transformations on tabular, relational, and multidimensional data. The term has widespread use in various contexts, but is primarily associated with specialized software designed specifically for data analysis.
+
+
+== Common data drilling operations ==
+There are certain operations that are common to applications that allow data drilling. Among them are:
+Query operations:
+
+tabular query
+pivot query
+
+
+=== Tabular query ===
+Tabular query operations consist of standard operations on data tables.
+Among these operations are:
+
+search
+sort
+filter (by value)
+filter (by extended function or condition)
+transform (e.g., by adding or removing columns)
+Consider the following example:
+Fred and Wilma table (Fig 001):
+
+   gender, fname, lname, home
+   male, fred, chopin, Poland
+   male, fred, flintstone, bedrock
+   male, fred, durst, usa
+   female, wilma, flintstone, bedrock
+   female, wilma, rudolph, usa
+   female, wilma, webb, usa
+   male, fred, johnson, usa
+
+The preceding is an example of a simple flat file table formatted as comma-separated values. The table includes first name, last name, gender and home country for various people named fred or wilma. Although the example is formatted this way, it is important to emphasize that tabular query  operations (as well as all data drilling operations) can be applied to any conceivable data type, regardless of the underlying formatting. The only requirement is that the data be readable by the software application in use.
+
+
+=== Pivot query ===
+A pivot query allows multiple representations of data according to different dimensions. This query type is similar to tabular query, except it also allows data to be represented in summary format, according to a flexible user-selected hierarchy. This class of data drilling operation is formally, (and loosely) known by different names, including crosstab query, pivot table, data pilot, selective hierarchy, intertwingularity and others.
+To illustrate the basics of pivot query operations, consider the Fred and Wilma table (Fig 001). A quick scan of the data reveals that the table has redundant information. This redundancy could be consolidated using an outline or a tree structure or in some other way. Moreover, once consolidated, the data could have many different alternate layouts.
+Using a simple text outline as output, the following alternate layouts are all possible with a pivot query:
+Summarize by gender (Fig 001):
+
+   female
+       flintstone, wilma
+       rudolph, wilma
+       webb, wilma
+   male
+       chopin, fred
+       flintstone, fred
+       durst, fred
+       johnson, fred
+   
+   (Dimensions = gender; Tabular fields = lname, fname;)
+
+Summarize by home, lname (Fig 001):
+
+   bedrock
+       flintstone
+           fred
+           wilma
+   Poland
+       chopin
+           fred
+   usa
+       ...
+   
+   (Dimensions = home, lname; Tabular fields = fname;)
+
+
+==== Uses ====
+Pivot query operations are useful for summarizing a corpus of data in multiple ways, thereby illustrating different representations of the same basic information. Although this type of operation appears prominently in spreadsheets and desktop database software, its flexibility is arguably under-utilized. There are many applications that allow only a 'fixed' hierarchy for representing data, and this represents a substantial limitation.
+
+
+== Drillup ==
+Drillup is the opposite of drilldown. For example, if you drilldown to see the revenue of one product, then you might want to drillup to see the revenue of all products.
+
+
+== References ==

data/en.wikipedia.org/wiki/Data_processing_inequality-0.md

@@ -0,0 +1,402 @@
+---
+title: "Data processing inequality"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Data_processing_inequality"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:29.558623+00:00"
+instance: "kb-cron"
+---
+
+The data processing inequality is an information theoretic concept that states that the information content of a signal cannot be increased via a local physical operation.  This can be expressed concisely as 'post-processing cannot increase information'. 
+
+
+== Statement ==
+Let three random variables form the Markov chain 
+  
+    
+      
+        X
+        →
+        Y
+        →
+        Z
+      
+    
+    {\displaystyle X\rightarrow Y\rightarrow Z}
+  
+, implying that the conditional distribution of 
+  
+    
+      
+        Z
+      
+    
+    {\displaystyle Z}
+  
+ depends only on 
+  
+    
+      
+        Y
+      
+    
+    {\displaystyle Y}
+  
+ and is conditionally independent of 
+  
+    
+      
+        X
+      
+    
+    {\displaystyle X}
+  
+. Specifically, we have such a Markov chain if the joint probability mass function can be written as
+
+  
+    
+      
+        p
+        (
+        x
+        ,
+        y
+        ,
+        z
+        )
+        =
+        p
+        (
+        x
+        )
+        p
+        (
+        y
+        
+          |
+        
+        x
+        )
+        p
+        (
+        z
+        
+          |
+        
+        y
+        )
+        =
+        p
+        (
+        y
+        )
+        p
+        (
+        x
+        
+          |
+        
+        y
+        )
+        p
+        (
+        z
+        
+          |
+        
+        y
+        )
+      
+    
+    {\displaystyle p(x,y,z)=p(x)p(y|x)p(z|y)=p(y)p(x|y)p(z|y)}
+  
+
+In this setting, no processing of 
+  
+    
+      
+        Y
+      
+    
+    {\displaystyle Y}
+  
+, deterministic or random, can increase the information that 
+  
+    
+      
+        Y
+      
+    
+    {\displaystyle Y}
+  
+ contains about 
+  
+    
+      
+        X
+      
+    
+    {\displaystyle X}
+  
+. Using the mutual information, this can be written as :
+
+  
+    
+      
+        I
+        (
+        X
+        ;
+        Y
+        )
+        ⩾
+        I
+        (
+        X
+        ;
+        Z
+        )
+        ,
+      
+    
+    {\displaystyle I(X;Y)\geqslant I(X;Z),}
+  
+
+with the equality 
+  
+    
+      
+        I
+        (
+        X
+        ;
+        Y
+        )
+        =
+        I
+        (
+        X
+        ;
+        Z
+        )
+      
+    
+    {\displaystyle I(X;Y)=I(X;Z)}
+  
+ if and only if 
+  
+    
+      
+        I
+        (
+        X
+        ;
+        Y
+        ∣
+        Z
+        )
+        =
+        0
+      
+    
+    {\displaystyle I(X;Y\mid Z)=0}
+  
+. That is, 
+  
+    
+      
+        Z
+      
+    
+    {\displaystyle Z}
+  
+ and 
+  
+    
+      
+        Y
+      
+    
+    {\displaystyle Y}
+  
+ contain the same information about 
+  
+    
+      
+        X
+      
+    
+    {\displaystyle X}
+  
+, and 
+  
+    
+      
+        X
+        →
+        Z
+        →
+        Y
+      
+    
+    {\displaystyle X\rightarrow Z\rightarrow Y}
+  
+ also forms a Markov chain.
+
+
+== Proof ==
+One can apply the chain rule for mutual information to obtain two different decompositions of 
+  
+    
+      
+        I
+        (
+        X
+        ;
+        Y
+        ,
+        Z
+        )
+      
+    
+    {\displaystyle I(X;Y,Z)}
+  
+:
+
+  
+    
+      
+        I
+        (
+        X
+        ;
+        Z
+        )
+        +
+        I
+        (
+        X
+        ;
+        Y
+        ∣
+        Z
+        )
+        =
+        I
+        (
+        X
+        ;
+        Y
+        ,
+        Z
+        )
+        =
+        I
+        (
+        X
+        ;
+        Y
+        )
+        +
+        I
+        (
+        X
+        ;
+        Z
+        ∣
+        Y
+        )
+      
+    
+    {\displaystyle I(X;Z)+I(X;Y\mid Z)=I(X;Y,Z)=I(X;Y)+I(X;Z\mid Y)}
+  
+
+By the relationship 
+  
+    
+      
+        X
+        →
+        Y
+        →
+        Z
+      
+    
+    {\displaystyle X\rightarrow Y\rightarrow Z}
+  
+, we know that 
+  
+    
+      
+        X
+      
+    
+    {\displaystyle X}
+  
+ and 
+  
+    
+      
+        Z
+      
+    
+    {\displaystyle Z}
+  
+ are conditionally independent, given 
+  
+    
+      
+        Y
+      
+    
+    {\displaystyle Y}
+  
+, which means the conditional mutual information, 
+  
+    
+      
+        I
+        (
+        X
+        ;
+        Z
+        ∣
+        Y
+        )
+        =
+        0
+      
+    
+    {\displaystyle I(X;Z\mid Y)=0}
+  
+. The data processing inequality then follows from the non-negativity of 
+  
+    
+      
+        I
+        (
+        X
+        ;
+        Y
+        ∣
+        Z
+        )
+        ≥
+        0
+      
+    
+    {\displaystyle I(X;Y\mid Z)\geq 0}
+  
+. 
+
+
+== See also ==
+Garbage in, garbage out
+
+
+== References ==
+
+
+== External links ==
+http://www.scholarpedia.org/article/Mutual_information

data/en.wikipedia.org/wiki/Data_truncation-0.md

@@ -0,0 +1,21 @@
+---
+title: "Data truncation"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Data_truncation"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:30.754364+00:00"
+instance: "kb-cron"
+---
+
+In databases and computer networking data truncation occurs when data or a data stream (such as a file) is stored in a location too short to hold its entire length.  Data truncation may occur automatically, such as when a long string is written to a smaller buffer, or deliberately, when only a portion of the data is wanted.
+Depending on what type of data validation a program or operating system has, the data may be truncated silently (i.e., without informing the user), or the user may be given an error message.
+For example, sometimes instead of rounding off a numerical value obtained from a calculation, some of the digits might just be removed i.e. truncated
+
+
+== See also ==
+Fixed-point arithmetic § Precision loss and overflow
+Data loss
+
+
+== References ==

data/en.wikipedia.org/wiki/Data_verification-0.md

@@ -0,0 +1,25 @@
+---
+title: "Data verification"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Data_verification"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:31.960862+00:00"
+instance: "kb-cron"
+---
+
+Data verification is a process in which different types of data are checked for accuracy and inconsistencies after data migration is done. In some domains it is referred to Source Data Verification (SDV), such as in clinical trials.
+Data verification helps to determine whether data was accurately translated when data is transferred from one source to another, is complete, and supports processes in the new system. During verification, there may be a need for a parallel run of both systems to identify areas of disparity and forestall erroneous data loss.
+Methods for data verification include double data entry, proofreading and automated verification of data. Proofreading data involves someone checking the data entered against the original document. This is also time-consuming and costly. Automated verification of data can be achieved using one way hashes locally or through use of a SaaS based service such as Q by SoLVBL to provide immutable seals to allow verification of the original data.
+
+
+== See also ==
+Data validation
+Verification and validation
+
+
+== References ==
+
+
+== External links ==
+PC Guide article

data/en.wikipedia.org/wiki/Database-as-IPC-0.md

@@ -0,0 +1,25 @@
+---
+title: "Database-as-IPC"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Database-as-IPC"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:34.422780+00:00"
+instance: "kb-cron"
+---
+
+In computer programming, Database-as-IPC may be considered an anti-pattern where a disk persisted table in a database is used as the message queue store for routine inter-process communication (IPC) or subscribed data processing. If database performance is of concern, alternatives include sockets, network socket, or message queue.
+British computer scientist, Junade Ali, defined the Database-as-IPC Anti-Pattern as using a database to "schedule jobs or queue up tasks to be completed", noting that this anti-pattern centres around using a database for temporary messages instead of persistent data.
+
+
+== Controversy ==
+The issue arises if there is a performance issue, and if additional systems (and servers) can be justified. In terms of performance, recent advancements in database systems provide more efficient mechanisms for signaling and messaging, and database systems also support memory (non-persisted) tables.
+There are databases with built-in notification mechanisms, such as PostgreSQL, SQL Server, and Oracle. These mechanisms and future improvements of database systems can make queuing much more efficient and avoid the need to set up a separate signaling or messaging queue system along with the server and management overhead.
+While MySQL doesn't have direct support for notifications, some workarounds are possible. However, they would be seen as non-standard and therefore more difficult to maintain.
+
+
+== See also ==
+Inbox and outbox pattern
+
+
+== References ==

data/en.wikipedia.org/wiki/Database_repair-0.md

@@ -0,0 +1,25 @@
+---
+title: "Database repair"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Database_repair"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:33.209522+00:00"
+instance: "kb-cron"
+---
+
+The problem of database repair is a question about relational databases which has been studied in database theory, and which is a particular kind of data cleansing. The problem asks about how we can "repair" an input relational database in order to make it satisfy integrity constraints. The goal of the problem is to be able to work with data that is "dirty", i.e., does not satisfy the right integrity constraints, by reasoning about all possible repairs of the data, i.e., all possible ways to change the data to make it satisfy the integrity constraints, without committing to a specific choice.
+Several variations of the problem exist, depending on:
+
+what we intend to figure out about the dirty data: figuring out if some database tuple is certain (i.e., is in every repaired database), figuring out if some query answer is certain (i.e., the answer is returned when evaluating the query on every repaired database)
+which kinds of ways are allowed to repair the database: can we insert new facts, remove facts (so-called subset repairs), and so on
+which repaired databases do we study: those where we only change a minimal subset of the database tuples (e.g., minimal subset repairs), those where we only change a minimal number of database tuples (e.g., minimal cardinality repairs)
+The problem of database repair has been studied to understand what is the complexity of these different problem variants, i.e., can we efficiently determine information about the state of the repairs, without explicitly materializing all of these repairs.
+
+
+== References ==
+Arenas, Marcelo; Bertossi, Leopoldo; Chomicki, Jan (1999). Consistent Query Answers in Inconsistent Databases (PDF). PODS.
+
+
+== See also ==
+Probabilistic database

data/en.wikipedia.org/wiki/Dave_rule-0.md

@@ -0,0 +1,15 @@
+---
+title: "Dave rule"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Dave_rule"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:35.610456+00:00"
+instance: "kb-cron"
+---
+
+The Dave rule is an inside joke in Silicon Valley startup culture that posits that if a work team includes as many women as it does people named Dave, it has achieved acceptable gender balance. The joke is a reference to Silicon Valley's infamous gender gap.
+The concept was in use in the Carnegie Mellon School of Computer Science under the name "Dave-to-girl ratio" or "Dave-to-female ratio" at least as early as 1999. It was first documented in Silicon Valley, which employs many Carnegie Mellon SCS alumni, under the name "Dave rule" in 2014 by Guardian newspaper correspondent Rory Carroll in an article about a sexual harassment lawsuit filed against dating application startup Tinder by a female former executive.
+
+
+== References ==

data/en.wikipedia.org/wiki/Deadline-monotonic_scheduling-0.md

@@ -0,0 +1,32 @@
+---
+title: "Deadline-monotonic scheduling"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Deadline-monotonic_scheduling"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:36.787570+00:00"
+instance: "kb-cron"
+---
+
+Deadline-monotonic priority assignment is a priority assignment policy used with fixed-priority pre-emptive scheduling.
+With deadline-monotonic priority assignment, tasks are assigned priorities according to their deadlines. The task with the shortest deadline is assigned the highest priority. This priority assignment policy is optimal for a set of periodic or sporadic tasks which comply with the following system model:
+
+All tasks have deadlines less than or equal to their minimum inter-arrival times (or periods).
+All tasks have worst-case execution times (WCET) that are less than or equal to their deadlines.
+All tasks are independent, and so do not block each other's execution (e.g., by accessing mutually exclusive shared resources).
+No task voluntarily suspends itself.
+There is some point in time, referred to as a critical instant, where all of the tasks become ready to execute simultaneously.
+Scheduling overheads (switching from one task to another) are zero.
+All tasks have zero release jitter (the time from the task arriving to it becoming ready to execute).
+If restriction 7 is lifted, then "deadline minus jitter" monotonic priority assignment is optimal.
+If restriction 1 is lifted, allowing deadlines greater than periods, then Audsley's optimal priority assignment algorithm may be used to find the optimal priority assignment.
+Deadline monotonic priority assignment is not optimal for fixed priority non-pre-emptive scheduling.
+A fixed priority assignment policy P is referred to as optimal if no task set exists which is schedulable using a different priority assignment policy which is not also schedulable using priority assignment policy P. Or in other words: Deadline-monotonic priority assignment (DMPA) policy is optimal if any process set, Q, that is schedulable by priority scheme W, is also schedulable by DMPA
+
+
+== See also ==
+Dynamic priority scheduling
+Rate-monotonic scheduling
+
+
+== References ==

data/en.wikipedia.org/wiki/Decentralized_object_location_and_routing-0.md

@@ -0,0 +1,14 @@
+---
+title: "Decentralized object location and routing"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Decentralized_object_location_and_routing"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:37.956164+00:00"
+instance: "kb-cron"
+---
+
+In computer science, decentralized object location and routing (DOLR) is a scalable, location-independent routing technology. It uses location-independent names, or aliases, for each node in the network, and it is an example of peer-to-peer networking that uses a structured-overlay system called Tapestry. It was designed to facilitate large internet applications with millions of users physically distributed around the globe and using a variety of wireless and wired interfaces, specifically in situations where a traditional unstructured network of popular Domain Name System servers would fail to perform well.
+
+
+== References ==

data/en.wikipedia.org/wiki/Defining_length-0.md

@@ -0,0 +1,24 @@
+---
+title: "Defining length"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Defining_length"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:39.149586+00:00"
+instance: "kb-cron"
+---
+
+In the field of genetic algorithms, a schema (plural: schemata) is a template that represents a subset of potential solutions. These templates use fixed symbols (e.g., `0` or `1`) for specific positions and a wildcard or "don't care" symbol (often `#` or `*`) for others.
+The defining length of a schema, denoted as L(H), measures the distance between the outermost fixed positions in the template. According to the Schema theorem, a schema with a shorter defining length is less likely to be disrupted by the genetic operator of crossover. As a result, short schemata are considered more robust and are more likely to be propagated to the next generation.
+In genetic programming, where solutions are often represented as trees, the defining length is the number of links in the minimum tree fragment that includes all the non-wildcard symbols within a schema H.
+
+
+== Example ==
+The defining length is calculated by subtracting the position of the first fixed symbol from the position of the last one. Using 1-based indexing for a string of length 5:
+
+The schema `1##0#` has its first fixed symbol (`1`) at position 1 and its last fixed symbol (`0`) at position 4. Its defining length is 4 − 1 = 3.
+The schema `00##0` has its first fixed symbol at position 1 and its last at position 5. Its defining length is 5 − 1 = 4.
+The schema `##0##` has only one fixed symbol at position 3. The first and last fixed positions are the same, so its defining length is 3 − 3 = 0.
+
+
+== References ==

data/en.wikipedia.org/wiki/Degree_of_isochronous_distortion-0.md

@@ -0,0 +1,17 @@
+---
+title: "Degree of isochronous distortion"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Degree_of_isochronous_distortion"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:40.297154+00:00"
+instance: "kb-cron"
+---
+
+The degree of isochronous distortion, in data transmission, is the ratio of the absolute value of the maximum measured difference between the actual and the theoretical intervals separating any two significant instants of modulation (or demodulation), to the unit interval. These instants are not necessarily consecutive.  This value is usually expressed as a percentage.
+The result of the measurement should be qualified by an indication if the period, usually limited, of the observation. For a prolonged modulation (or demodulation), it will be appropriate to consider the probability that an assigned value of the degree of distortion will be exceeded.
+
+
+== References ==
+
+ This article incorporates public domain material from Federal Standard 1037C. General Services Administration. Archived from the original on 22 January 2022. (in support of MIL-STD-188).

data/en.wikipedia.org/wiki/Degree_of_parallelism-0.md

@@ -0,0 +1,19 @@
+---
+title: "Degree of parallelism"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Degree_of_parallelism"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:41.491362+00:00"
+instance: "kb-cron"
+---
+
+The degree of parallelism (DOP) is a metric which indicates how many operations can be or are being simultaneously executed by a computer. It is used as an indicator of the complexity of algorithms, and is especially useful for describing the performance of parallel programs and multi-processor systems.
+A program running on a parallel computer may utilize different numbers of processors at different times. For each time period, the number of processors used to execute a program is defined as the degree of parallelism. The plot of the DOP as a function of time for a given program is called the parallelism profile.
+
+
+== See also ==
+Optical Multi-Tree with Shuffle Exchange
+
+
+== References ==

data/en.wikipedia.org/wiki/Derivative_code-0.md

@@ -0,0 +1,21 @@
+---
+title: "Derivative code"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Derivative_code"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:42.679746+00:00"
+instance: "kb-cron"
+---
+
+Derivative code or Chameleon code is source code which has been derived entirely from one or more other machine readable file formats.  If recursive transcompiling is used in the development process, some code will survive all the way through the pipeline from beginning to end, and then back to the beginning again.
+This code is, by definition, derivative code.  The following procedure can be used to easily test if any source code is derivative code or not.  
+
+Delete the code in question
+Build (or compile) the project
+If the build process simply replaces the source code which has been deleted, it is (obviously) code which has been derived from something else and is therefore, by definition, derivative code.
+If the build process fails, and a human needs to re-create the deleted code by hand, this is again, by definition, hand code.
+The transcompilers and other tools which create derivative code, are usually themselves either in part, or entirely hand code.
+
+
+== References ==

data/en.wikipedia.org/wiki/Design_By_Numbers-0.md

@@ -0,0 +1,42 @@
+---
+title: "Design By Numbers"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Design_By_Numbers"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:43.852048+00:00"
+instance: "kb-cron"
+---
+
+Design By Numbers (DBN) was an influential experiment in teaching programming initiated at the MIT Media Lab during the 1990s. Led by John Maeda and his students they created software aimed at allowing designers, artists and other non-programmers to easily start computer programming.
+The software itself can be run in a browser and published alongside the software was a book and courseware.
+Design By Numbers is no longer an active project but has gone on to influence many other projects aimed at making computer programming more accessible to non-technical people. Its most public result is Processing, created by Maeda's students Casey Reas and Ben Fry, who built on the work of DBN and has gone on to international success.
+
+
+== History ==
+Design By Numbers was developed by Aesthetics and Computation Group (1996-2003) at the MIT Media Lab.
+The first version of DNB was created by John Maeda in 1999. DNB 1.0.1 was developed by Tom White. DBN 2 and 3 by Ben Fry. In late 2002, John Maeda took over the further development of DNB.
+Prof. Warren Sack provided a toolkit for doing LOGO-style graphics in January 22, 2003.
+The last version of DNB (3.0.1) was released in 2003. Beta version of DNB 4, developed by Jessica Rosenkrantz, was scheduled for release in August 2003, but ultimately never came out. For a time, DNB 4 was intended to be the final version of the language. 
+In 2005, John Maeda announced that he would continue developing DNB as part of the MIT Physical Language Workshop (PLW) research group. The status of the new version of DNB or its derivatives is unknown. PLW remained active until 2008.
+
+
+== Features ==
+DNB consists of an IDE and a programming language.
+DNB program can be written four languages: English (default), Spanish, French, and Japanese. Each command has been translated into the appropriate language, e.g. the equivalents of the command paper are: papel (es), papier (fr), かみ (jp).
+
+
+== See also ==
+Processing
+Smile software
+
+
+== References ==
+
+
+== Further reading ==
+Maeda, John (October 1, 2001). Design By Numbers. Foreword by Paola Antonelli. MIT Press. ISBN 978-0-262-63244-7.
+
+
+== External links ==
+Official website

data/en.wikipedia.org/wiki/Deterministic_parsing-0.md

@@ -0,0 +1,21 @@
+---
+title: "Deterministic parsing"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Deterministic_parsing"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:45.116449+00:00"
+instance: "kb-cron"
+---
+
+In natural language processing, deterministic parsing refers to parsing algorithms that do not backtrack. LR-parsers are an example. (This meaning of the words "deterministic" and "non-deterministic" differs from that used to describe nondeterministic algorithms.)
+The deterministic behavior is desired and expected in compiling programming languages. In natural language processing, it was thought for a long time that deterministic parsing is impossible due to ambiguity inherent in natural languages (many sentences have more than one plausible parse). Thus, non-deterministic approaches such as the chart parser had to be applied. However, Mitch Marcus proposed in 1978 the Parsifal parser that was able to deal with ambiguities while still keeping the deterministic behavior.
+
+
+== See also ==
+Deterministic context-free grammar
+
+
+== References ==
+Alfred V. Aho, Stephen C. Johnson, Jeffrey D. Ullman (1975): Deterministic parsing of ambiguous grammars. Comm. ACM 18:8:441-452.
+Mitchell Marcus (1978): A Theory of Syntactic Recognition for Natural Language. PhD Thesis, Department of Electrical Engineering and Computer Science, Massachusetts Institute of Technology.

data/en.wikipedia.org/wiki/Dichotomic_search-0.md

@@ -0,0 +1,26 @@
+---
+title: "Dichotomic search"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Dichotomic_search"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:46.335752+00:00"
+instance: "kb-cron"
+---
+
+In computer science, a dichotomic search is a search algorithm that operates by selecting between two distinct alternatives (dichotomies or polychotomies when they are more than two) at each step. It is a specific type of divide and conquer algorithm. A well-known example is binary search.
+Abstractly, a dichotomic search can be viewed as following edges of an implicit binary tree structure until it reaches a leaf (a goal or final state). This creates a theoretical tradeoff between the number of possible states and the running time: given k comparisons, the algorithm can only reach O(2k) possible states and/or possible goals.
+Some dichotomic searches only have results at the leaves of the tree, such as the Huffman tree used in Huffman coding, or the implicit classification tree used in Twenty Questions. Other dichotomic searches also have results in at least some internal nodes of the tree, such as a dichotomic search table for Morse code. There is thus some looseness in the definition. Though there may indeed be only two paths from any node, there are thus three possibilities at each step: choose one onwards path or the other, or stop at this node.
+Dichotomic searches are often used in repair manuals, sometimes graphically illustrated with a flowchart similar to a fault tree.
+
+
+== See also ==
+Binary search algorithm
+
+
+== References ==
+
+
+== External links ==
+Python Program for Binary Search (Recursive and Iterative)
+Binary Search

data/en.wikipedia.org/wiki/Differential_privacy_composition_theorems-0.md

@@ -0,0 +1,15 @@
+---
+title: "Differential privacy composition theorems"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Differential_privacy_composition_theorems"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:47.524010+00:00"
+instance: "kb-cron"
+---
+
+Differential privacy composition theorems are mathematical tools used in differential privacy to analyze and bound the accumulated privacy loss when multiple differentially private mechanisms are applied to the same dataset. They quantify how privacy guarantees degrade as more queries or analyses are performed, and are essential for designing complex differentially private systems and algorithms.
+For example, if user submits multiple queries to a differentially private database, each query might individually satisfies ε-differential privacy but the repeated interaction can cumulatively leak more information than intended. Composition theorems address this by providing a way to calculate the overall privacy loss after multiple mechanisms have been applied.
+
+
+== References ==

data/en.wikipedia.org/wiki/Disruptor_(software)-0.md

@@ -0,0 +1,23 @@
+---
+title: "Disruptor (software)"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Disruptor_(software)"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:48.676079+00:00"
+instance: "kb-cron"
+---
+
+Disruptor is a library for the Java programming language that provides a concurrent ring buffer data structure of the same name, developed at LMAX Exchange. It is designed to provide a low-latency, high-throughput work queue in asynchronous event processing architectures. It ensures that any data is owned by only one thread for write access, therefore reducing write contention compared to other structures. The library is used for asynchronous logging in the popular Java software library Log4j.
+
+
+== See also ==
+Concurrent data structure
+
+
+== References ==
+
+
+== External links ==
+
+LMAX Disruptor: High Performance Inter-Thread Messaging Library

data/en.wikipedia.org/wiki/Distributed_design_patterns-0.md

@@ -0,0 +1,34 @@
+---
+title: "Distributed design patterns"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Distributed_design_patterns"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:49.900529+00:00"
+instance: "kb-cron"
+---
+
+In software engineering, a distributed design pattern is a software design pattern focused on distributed computing problems.
+
+
+== Classification ==
+Distributed design patterns can be divided into several groups:
+
+Distributed communication patterns
+Security and reliability patterns
+Event-driven patterns
+Saga pattern
+
+
+== Examples ==
+MapReduce
+Bulk synchronous parallel
+Remote Session
+
+
+== See also ==
+Software engineering
+Outline of software engineering
+
+
+== References ==

data/en.wikipedia.org/wiki/Divergence_(computer_science)-0.md

@@ -0,0 +1,192 @@
+---
+title: "Divergence (computer science)"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Divergence_(computer_science)"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:51.109324+00:00"
+instance: "kb-cron"
+---
+
+In computer science, a computation is said to diverge if it does not terminate or terminates in an exceptional state. Otherwise it is said to converge. In domains where computations are expected to be infinite, such as process calculi, a computation is said to diverge if it fails to be productive (i.e. to continue producing an action within a finite amount of time).
+
+
+== Definitions ==
+Various subfields of computer science use varying, but mathematically precise, definitions of what it means for a computation to converge or diverge.
+
+
+=== Rewriting ===
+In abstract rewriting, an abstract rewriting system is called convergent if it is both confluent and terminating.
+The notation t ↓ n means that t reduces to normal form n in zero or more reductions, t↓ means t reduces to some normal form in zero or more reductions, and t↑ means t does not reduce to a normal form; the latter is impossible in a terminating rewriting system.
+In the lambda calculus an expression is divergent if it has no normal form.
+
+
+=== Denotational semantics ===
+In denotational semantics an object function f : A → B can be modelled as a mathematical function 
+  
+    
+      
+        f
+        :
+        A
+        ∪
+        {
+        ⊥
+        }
+        →
+        B
+        ∪
+        {
+        ⊥
+        }
+      
+    
+    {\displaystyle f:A\cup \{\perp \}\rightarrow B\cup \{\perp \}}
+  
+ where ⊥ (bottom) indicates that the object function or its argument diverges.
+
+
+=== Concurrency theory ===
+
+In the calculus of communicating sequential processes (CSP), divergence occurs when a process performs an endless series of hidden actions. For example, consider the following process, defined by CSP notation:
+
+  
+    
+      
+        C
+        l
+        o
+        c
+        k
+        =
+        t
+        i
+        c
+        k
+        →
+        C
+        l
+        o
+        c
+        k
+      
+    
+    {\displaystyle Clock=tick\rightarrow Clock}
+  
+
+The traces of this process are defined as:
+
+  
+    
+      
+        traces
+        ⁡
+        (
+        C
+        l
+        o
+        c
+        k
+        )
+        =
+        {
+        ⟨
+        ⟩
+        ,
+        ⟨
+        t
+        i
+        c
+        k
+        ⟩
+        ,
+        ⟨
+        t
+        i
+        c
+        k
+        ,
+        t
+        i
+        c
+        k
+        ⟩
+        ,
+        …
+        }
+        =
+        {
+        t
+        i
+        c
+        k
+        
+          }
+          
+            ∗
+          
+        
+      
+    
+    {\displaystyle \operatorname {traces} (Clock)=\{\langle \rangle ,\langle tick\rangle ,\langle tick,tick\rangle ,\ldots \}=\{tick\}^{*}}
+  
+
+Now, consider the following process, which hides the tick event of the Clock process:
+
+  
+    
+      
+        P
+        =
+        C
+        l
+        o
+        c
+        k
+        ∖
+        t
+        i
+        c
+        k
+      
+    
+    {\displaystyle P=Clock\setminus tick}
+  
+
+As 
+  
+    
+      
+        P
+      
+    
+    {\displaystyle P}
+  
+ cannot do anything other than perform hidden actions forever, it is equivalent to the process that does nothing but diverge, denoted 
+  
+    
+      
+        
+          d
+          i
+          v
+        
+      
+    
+    {\displaystyle \mathbf {div} }
+  
+. One semantic model of CSP is the failures-divergences model, which refines the stable failures model by distinguishing processes based on the sets of traces after which they can diverge.
+
+
+== See also ==
+Infinite loop
+Termination analysis
+
+
+== Notes ==
+
+
+== References ==
+Baader, Franz; Nipkow, Tobias (1998). Term Rewriting and All That. Cambridge University Press. ISBN 9780521779203.
+Pierce, Benjamin C. (2002). Types and Programming Languages. MIT Press.
+J. M. R. Martin and S. A. Jassim (1997). "How to Design Deadlock-Free Networks Using CSP and Verification Tools: A Tutorial Introduction" in Proceedings of the WoTUG-20.

data/en.wikipedia.org/wiki/Docking@Home-0.md

@@ -4,7 +4,7 @@ chunk: 1/1
 source: "https://en.wikipedia.org/wiki/Docking@Home"
 category: "reference"
 tags: "science, encyclopedia"
-date_saved: "2026-05-05T10:11:05.279096+00:00"
+date_saved: "2026-05-05T11:32:52.343469+00:00"
 instance: "kb-cron"
 ---
 

data/en.wikipedia.org/wiki/Doo–Sabin_subdivision_surface-0.md

@@ -0,0 +1,52 @@
+---
+title: "Doo–Sabin subdivision surface"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Doo–Sabin_subdivision_surface"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:53.796315+00:00"
+instance: "kb-cron"
+---
+
+In 3D computer graphics, a Doo–Sabin subdivision surface is a type of subdivision surface based on a generalization of bi-quadratic uniform B-splines, whereas Catmull-Clark was based on generalized bi-cubic uniform B-splines. The subdivision refinement algorithm was developed in 1978 by Daniel Doo and Malcolm Sabin.
+The Doo-Sabin process generates one new face at each original vertex, ⁠
+  
+    
+      
+        n
+      
+    
+    {\displaystyle n}
+  
+⁠ new faces along each original edge, and ⁠
+  
+    
+      
+        
+          n
+          
+            2
+          
+        
+      
+    
+    {\displaystyle n^{2}}
+  
+⁠ new faces at each original face. A primary characteristic of the Doo–Sabin subdivision method is the creation of four faces and four edges (valence 4) around every new vertex in the refined mesh. A drawback is that the faces created at the original vertices  may be triangles or n-gons that are not necessarily coplanar.
+
+
+== Evaluation ==
+Doo–Sabin surfaces are defined recursively. Like all subdivision procedures, each refinement iteration, following the procedure given, replaces the current mesh with a "smoother", more refined mesh. After many iterations, the surface will gradually converge onto a smooth limit surface.
+Just as for Catmull–Clark surfaces, Doo–Sabin limit surfaces can also be evaluated directly without any recursive refinement, by means of the technique of Jos Stam. The solution is, however, not as computationally efficient as for Catmull–Clark surfaces because the Doo–Sabin subdivision matrices are not (in general) diagonalizable.
+
+
+== See also ==
+Expansion (equivalent geometric operation) - facets are moved apart after being separated, and new facets are formed
+Conway polyhedron notation - a set of related topological polyhedron and polygonal mesh operators
+Catmull-Clark subdivision surface
+Loop subdivision surface
+
+
+== External links ==
+
+Doo–Sabin surfaces

data/en.wikipedia.org/wiki/Driver_wrapper-0.md

@@ -0,0 +1,28 @@
+---
+title: "Driver wrapper"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Driver_wrapper"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:55.039847+00:00"
+instance: "kb-cron"
+---
+
+A driver wrapper is a subroutine in a software library that functions as an adapter between an operating system and a driver, such as a device driver, that was not designed for that operating system. It can enable the use of devices for which no drivers for the particular operating system are available. In particular, as of 2010 Microsoft Windows is the dominant family of operating systems for IBM PC compatible computers, and many devices are supplied with drivers for Windows but not other operating systems.
+
+
+== Windows driver wrappers for Linux ==
+Several open-source software projects allow using Microsoft Windows drivers under another operating system, such as Linux.
+Examples include network drivers for wireless cards (such as NDISwrapper for Linux or Project Evil for FreeBSD) and the NTFS file system (see Captive NTFS).
+The common thread among these examples is the use of wrapper technology, which allows execution of the drivers in a foreign environment.
+Limitations for driver wrappers include inability to function at real time. An example of this limitation includes latency problems as those associated with attempts to make compatible with Linux the ZoomR16 audio DAW sound recorder and control surface.
+
+
+== See also ==
+
+Compatibility layer
+Wrapper function
+Wrapper library
+
+
+== References ==

data/en.wikipedia.org/wiki/Dynamic_data-0.md

@@ -0,0 +1,25 @@
+---
+title: "Dynamic data"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Dynamic_data"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:57.426721+00:00"
+instance: "kb-cron"
+---
+
+Dynamic data or transactional data is a concept and practice in data management. It is information that is periodically updated, meaning it changes asynchronously over time as new information becomes available. The concept is important in data management, since the time scale of the data determines how it is processed and stored.
+Data that is not dynamic is considered either static (unchanging) or persistent, which is data that is infrequently accessed and not likely to be modified. Dynamic data is also different from streaming data, which is a constant flow of information. Dynamic data may be updated at any time, with periods of inactivity in between.
+
+
+== Examples ==
+In enterprise data management, dynamic data is likely to be transactional, but it is not limited to financial or business transactions. It may also include engineering transactions, such as a revised schematic diagram or architectural document. In this context static data is either unchanged or so rarely changed that it can be stored remotely ("basement" or far) storage, whereas dynamic data is reused or changed frequently and therefore requires online ("office" or near) storage. An original copy of a wiring schematic will change from dynamic to static as the new versions make it obsolete. It is still possible to reuse the original, but in the normal course of business there is rarely a need to access obsoleted data. The current version of the wiring schematic is considered dynamic or changeable.
+These two different contexts for "dynamic" are similar, but differ their time scale. Dynamic data can become static.
+Persistent data is or is likely to be in the context of the execution of a program. Static data is in the context of the business historical data, regardless of any one application or program. The "dynamic" data is the new/updated/revised/deleted data in both cases, but again over different time horizons. Your paycheck stub is dynamic data for 1 week, or 1 day, then it becomes read-only and read-rarely, which would be either or both static and persistent.
+
+
+== See also ==
+Transaction data
+
+
+== References ==

data/en.wikipedia.org/wiki/Dynamic_link_matching-0.md

@@ -0,0 +1,18 @@
+---
+title: "Dynamic link matching"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Dynamic_link_matching"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:58.627298+00:00"
+instance: "kb-cron"
+---
+
+Dynamic link matching is a graph-based system for image recognition.  It uses wavelet transformations to encode incoming image data.
+
+
+== References ==
+
+
+== External links ==
+Original paper on Dynamic Link Matching

data/en.wikipedia.org/wiki/Dynamic_priority_scheduling-0.md

@@ -0,0 +1,93 @@
+---
+title: "Dynamic priority scheduling"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Dynamic_priority_scheduling"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:32:59.835091+00:00"
+instance: "kb-cron"
+---
+
+Dynamic priority scheduling is a type of scheduling algorithm in which the priorities are calculated during the execution of the system. The goal of dynamic priority scheduling is to adapt to dynamically changing progress and to form an optimal configuration in a self-sustained manner. It can be very hard to produce well-defined policies to achieve the goal depending on the difficulty of a given problem.
+Earliest deadline first scheduling and Least slack time scheduling are examples of Dynamic priority scheduling algorithms.
+
+
+== Optimal schedulable utilization ==
+The idea of real-time scheduling is to confine processor utilization under schedulable utilization of a certain scheduling algorithm, which is scaled from 0 to 1. Higher schedulable utilization means higher utilization of resource and the better the algorithm. In preemptible scheduling, dynamic priority scheduling such as earliest deadline first (EDF) provides the optimal schedulable utilization of 1 in contrast to less than 0.69 with fixed priority scheduling such as rate-monotonic (RM).
+In periodic real-time task model, a task's processor utilization is defined as execution time over period. Every set of periodic tasks with total processor utilization less or equal to the schedulable utilization of an algorithm can be feasibly scheduled by that algorithm. Unlike fixed priority, dynamic priority scheduling could dynamically prioritize task deadlines achieving optimal schedulable utilization in the preemptible case.
+
+
+== Least slack time scheduling ==
+Least slack time (LST) scheduling or least laxity first is an algorithm for dynamic priority scheduling. The algorithm assigns priorities to processes based on their slack time. Slack time is the amount of time left after a job if the job was started now. Its most common use is in embedded systems, especially those with multiple processors. It imposes the simple constraint that each process on each available processor possesses the same run time, and that individual processes do not have an affinity to a certain processor. This is what lends it a suitability to embedded systems.
+This scheduling algorithm first selects those processes that have the smallest "slack time". Slack time is defined as the temporal difference between the deadline, the ready time and the run time.
+More formally, the slack time 
+  
+    
+      
+        s
+      
+    
+    {\displaystyle s}
+  
+ for a process is defined as:
+
+  
+    
+      
+        s
+        =
+        (
+        d
+        −
+        t
+        )
+        −
+        
+          c
+          ′
+        
+      
+    
+    {\displaystyle s=(d-t)-c'}
+  
+
+where 
+  
+    
+      
+        d
+      
+    
+    {\displaystyle d}
+  
+ is the process deadline, 
+  
+    
+      
+        t
+      
+    
+    {\displaystyle t}
+  
+ is the real time since the cycle start, and 
+  
+    
+      
+        
+          c
+          ′
+        
+      
+    
+    {\displaystyle c'}
+  
+ is the remaining computation time.
+In realtime scheduling algorithms for periodic jobs, an acceptance test is needed before accepting a sporadic job with a hard deadline. One of the simplest acceptance tests for a sporadic job is calculating the amount of slack time between the release time and deadline of the job.
+LST scheduling is most useful in systems comprising mainly aperiodic tasks, because no prior assumptions are made on the events' rate of occurrence. The main weakness of LST is that it does not look ahead, and works only on the current system state. Thus, during a brief overload of system resources, LST can be suboptimal. It will also be suboptimal when used with uninterruptible processes. However, like the earliest deadline first, and unlike rate monotonic scheduling, this algorithm can be used for processor utilization up to 100%.
+
+
+== See also ==
+Earliest deadline first scheduling - a different algorithm for dynamic priority scheduling, which guarantees optimal throughput.
+
+
+== References ==

data/en.wikipedia.org/wiki/Dynamic_problem_(algorithms)-0.md

@@ -0,0 +1,143 @@
+---
+title: "Dynamic problem (algorithms)"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Dynamic_problem_(algorithms)"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:33:01.014695+00:00"
+instance: "kb-cron"
+---
+
+In computer science, dynamic problems are problems stated in terms of changing input data. In its most general form, a problem in this category is usually stated as follows:
+
+Given a structure composed of objects, find efficient algorithms and data structures to answer certain queries about the structure, while also efficiently supporting update operations such as insertion, deletion or modification of objects in the structure.
+Problems in this class have the following measures of complexity:
+
+Space –  the amount of memory space required to store the data structure;
+Initialization time –  time required for the initial construction of the data structure;
+Insertion time –  time required for the update of the data structure when one more input element is added;
+Deletion time –  time required for the update of the data structure when an input element is deleted;
+Query time –  time required to answer a query;
+Other operations specific to the problem in question
+The overall set of computations for a dynamic problem is called a dynamic algorithm.
+Many algorithmic problems stated in terms of fixed input data (called static problems in this context and solved by static algorithms) have meaningful dynamic versions.
+
+
+== Special cases ==
+Incremental algorithms, or online algorithms, are algorithms in which only additions of elements are allowed, possibly starting from empty/trivial input data.
+Decremental algorithms are algorithms in which only deletions of elements are allowed, starting with the initialization of a full data structure.
+If both additions and deletions are allowed, the algorithm is sometimes called fully dynamic.
+
+
+== Examples ==
+
+
+=== Maximal element ===
+Static problem
+For a set of N numbers find the maximal one.
+The problem may be solved in O(N) time.
+
+Dynamic problem
+For an initial set of N numbers, dynamically maintain the maximal one when insertions and deletions are allowed.
+This is just the priority queue maintenance problem allowing for insertions and deletions; it can be solved, for example, using a 
+binary heap in 
+  
+    
+      
+        O
+        (
+        log
+        ⁡
+        N
+        )
+      
+    
+    {\displaystyle O(\log N)}
+  
+ time for an update and 
+  
+    
+      
+        O
+        (
+        1
+        )
+      
+    
+    {\displaystyle O(1)}
+  
+ time for a query, with 
+  
+    
+      
+        O
+        (
+        N
+        )
+      
+    
+    {\displaystyle O(N)}
+  
+ setup time (i.e., the initial processing of the data). Note that the value of N may change during the life of the structure.
+
+
+=== Graphs ===
+Given a graph, maintain its parameters, such as connectivity, maximal degree, shortest paths, etc., when insertion and deletion of its edges are allowed.
+Examples:
+
+There is an algorithm that maintains the minimum spanning forest of a weighted, undirected graph, subject to edge deletions and insertions, in 
+  
+    
+      
+        O
+        (
+        
+          n
+          
+            1
+            
+              /
+            
+            2
+          
+        
+        )
+      
+    
+    {\displaystyle O(n^{1/2})}
+  
+ time per update.
+There is an algorithm that maintains the minimum spanning forest of a weighted, undirected graph, subject to edge deletions and insertions, in 
+  
+    
+      
+        O
+        (
+        
+          n
+          
+            1
+            
+              /
+            
+            3
+          
+        
+        log
+        ⁡
+        n
+        )
+      
+    
+    {\displaystyle O(n^{1/3}\log n)}
+  
+ amortized time per update.
+
+
+== See also ==
+Dynamization
+Dynamic connectivity
+Kinetic data structure
+
+
+== References ==

data/en.wikipedia.org/wiki/EPAM-0.md

@@ -0,0 +1,27 @@
+---
+title: "EPAM"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/EPAM"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:33:14.054957+00:00"
+instance: "kb-cron"
+---
+
+EPAM (Elementary Perceiver and Memorizer) is a  psychological theory of learning and memory implemented as a computer program. Originally designed by Herbert A. Simon and Edward Feigenbaum to simulate phenomena in verbal learning, it has been later adapted to account for data on the psychology of expertise and concept formation. It was influential in formalizing the concept of a chunk.  In EPAM, learning consists in the growth of a discrimination network.
+EPAM was written in IPL/V.
+The project was started in the late 1950s with the aim to learn nonsense syllables. The term nonsense is used because the learned patterns are not connected with a meaning but they are standing for their own. The software is working internally by creating a decision tree. An improved version is available under the name “EPAM-VI”.
+
+
+== Related cognitive models ==
+CHREST
+Soar
+
+
+== References ==
+
+Feigenbaum, E. A., & Simon, H. A. (1962). A theory of the serial position effect. British Journal of Psychology, 53, 307–320.
+Feigenbaum, E. A., & Simon, H. A. (1984). EPAM-like models of recognition and learning. Cognitive Science, 8, 305–336.
+Gobet, F., Richman, H. B., Staszewski, J. J., & Simon, H. A. (1997). Goals, representations, and strategies in a concept attainment task: The EPAM model. The Psychology of Learning and Motivation, 37, 265–290.
+Richman, H. B., Gobet, F., Staszewski, J. J., & Simon, H. A. (1996). Perceptual and memory processes in the acquisition of expert performance: The EPAM model. In K. A. Ericsson (Ed.), The road to excellence (pp. 167–187). Mahwah, NJ: Erlbaum.
+Richman, H. B., Staszewski, J. J., & Simon, H. A. (1995). Simulation of expert memory with EPAM IV. Psychological Review, 102, 305–330.

data/en.wikipedia.org/wiki/Edge_loop-0.md

@@ -0,0 +1,24 @@
+---
+title: "Edge loop"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Edge_loop"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:33:02.188242+00:00"
+instance: "kb-cron"
+---
+
+An edge loop, in computer graphics, can loosely be defined as a set of connected edges across a surface. (More specifically, the edges can form an edge ring and be one side of a face loop.) Usually, the last edge meets again with the first edge, thus forming a loop. The set or string of edges can, for example, be the outer edges of a flat surface or the edges surrounding a 'hole' in a surface.
+
+In a stricter sense, an edge loop is defined as a set of edges where the loop follows the middle edge in every 'four way junction'. The loop will end when it encounters another type of junction (three or five way, for example). Take an edge on a mesh surface for example, say at one end of the edge it connects with three other edges, making a four way junction. If you follow the middle 'road' each time, you would either end up with a completed loop or the edge loop would end at another type of junction.
+Edge loops are especially practical in organic models which need to be animated. In organic modeling, edge loops play a vital role in proper deformation of the mesh. A properly modeled mesh  will take into careful consideration the placement and termination of these edge loops. Generally, edge loops follow the structure and contour of the muscles that they mimic. For example, in modeling a human face, edge loops should follow the orbicularis oculi muscle around the eyes and the orbicularis oris muscle around the mouth. The hope is that by mimicking the way the muscles are formed, they also aid in the way the muscles are deformed by way of contractions and expansions. An edge loop closely mimics how real muscles work, and if built correctly, provides control over contour and silhouette in any position.
+"Edge loop" was first coined as a modelling term in 1999 by 3D artist Bay Raitt, in an article called Digital sculpting techniques for 3D Design magazine.
+
+
+== References ==
+
+
+== External links ==
+"First appearance of Edge loops in an 3D world magazine article 'Digital Sculpting techniques'" (PDF). Bay Raitt. Archived (PDF) from the original on 2017-05-16. Retrieved 2017-04-16.
+"Edge Loop". CG Society. Archived from the original on 2011-03-24. Retrieved 2017-07-04.
+[1], Another Description from 2000

data/en.wikipedia.org/wiki/Education_informatics-0.md

@@ -0,0 +1,17 @@
+---
+title: "Education informatics"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Education_informatics"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:33:03.447193+00:00"
+instance: "kb-cron"
+---
+
+Education Informatics is a sub-field of informatics. The primary focus is on computer applications, systems and networks that support research in and delivery of education. Education informatics is based upon information science, computer science and education but particularly addresses the intersection of these broad areas. Note that it is distinct from Informatics Education, a term that relates more to the practice of teaching/learning about informatics, rather than the use of information science and technology in the support of teaching and learning. The term has been in use since at least 1980.
+
+
+== References ==
+Carr, Jo Ann; O'Brien, Nancy P. (2010). "Policy Implications of Education Informatics". Teachers College Record 112 (10): 2703–2710.
+Ford, Nigel (2008). Web-based learning through educational informatics: Information science meets educational computing. Hershey, NY: Information Science Publishing.
+Levy, Philippa et Nigel Ford, Jonathon Foster, Andrew Madden, David Miller, Miguel Baptista Nunes, Maggie McPherson and Sheila Webber (2003). Educational informatics: an emerging research agenda. Journal of Information Science, 29 (4) 2003, pp. 298–310.

data/en.wikipedia.org/wiki/Eight_Ones-0.md

@@ -0,0 +1,31 @@
+---
+title: "Eight Ones"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Eight_Ones"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:33:04.650507+00:00"
+instance: "kb-cron"
+---
+
+EO, or Eight Ones, is an 8-bit EBCDIC character code represented as all ones (binary 1111 1111, hexadecimal FF).
+
+
+== As a control code ==
+Eight Ones, as an EBCDIC control code, is used for synchronisation purposes, such as a time and media filler. In Advanced Function Presentation code page definition resource headers, setting at least the first two bytes of the field for the eight-byte code page resource name (which is encoded in code page 500) to Eight Ones (0xFF) constitutes a "null name", which is treated as unset.
+
+
+=== Mapping ===
+When translated from the EBCDIC character set to code pages with a C1 control code set, Eight Ones is typically mapped to hexadecimal code 0x9F, in order to provide a unique character mapping in both directions. Prior to 1986, however, the C1 control code 0x9F was usually mapped to EBCDIC 0xE1, which was frequently used as a numeric (figure) space in code pages at the time (including the pre-1986 version of code page 37). The Unix dd utility follows the earlier convention, mapping the C1 code 0x9F to EBCDIC 0xE1, and mapping 0xFF (Eight Ones) to 0xFF.
+
+
+== As a graphical character ==
+While Eight Ones is treated as a control code by IBM EBCDIC infrastructure, EBCDIC code pages from Fujitsu Siemens used on the BS2000 system frequently use it for a graphical character, most often the tilde. In these cases, the C1 control code 0x9F is mapped to a different location in the EBCDIC code page, most commonly 0x5F.
+
+
+== See also ==
+0xFF
+Delete character
+
+
+== References ==

data/en.wikipedia.org/wiki/Elastic_matching-0.md

@@ -0,0 +1,22 @@
+---
+title: "Elastic matching"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Elastic_matching"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:33:05.793214+00:00"
+instance: "kb-cron"
+---
+
+Elastic matching is one of the pattern recognition techniques in computer science. Elastic matching (EM) is also known as deformable template, flexible matching, or nonlinear template matching.
+Elastic matching can be defined as an optimization problem of two-dimensional warping specifying corresponding pixels between subjected images.
+
+
+== References ==
+
+Uchida, Seiichi (August 2005). "A Survey of Elastic Matching Techniques for Handwritten Character Recognition" (PDF). IEICE Transactions on Information and Systems. E88-D (8): 1781–1790. Bibcode:2005IEITI..88.1781U. doi:10.1093/ietisy/e88-d.8.1781.
+
+
+== See also ==
+Dynamic time warping
+Graphical time warping

data/en.wikipedia.org/wiki/Emptiness_problem-0.md

@@ -0,0 +1,59 @@
+---
+title: "Emptiness problem"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Emptiness_problem"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:33:06.962515+00:00"
+instance: "kb-cron"
+---
+
+In theoretical computer science and formal language theory, a formal language is empty if its set of valid sentences is the empty set. The emptiness problem is the question of determining whether a language is empty given some representation of it, such as a finite-state automaton. For an automaton having 
+  
+    
+      
+        n
+      
+    
+    {\displaystyle n}
+  
+ states, this is a decision problem that can be solved in 
+  
+    
+      
+        O
+        (
+        
+          n
+          
+            2
+          
+        
+        )
+      
+    
+    {\displaystyle O(n^{2})}
+  
+ time, or in time 
+  
+    
+      
+        O
+        (
+        n
+        +
+        m
+        )
+      
+    
+    {\displaystyle O(n+m)}
+  
+ if the automaton has n states and m transitions. However, variants of that question, such as the emptiness problem for non-erasing stack automata, are PSPACE-complete. The emptiness problem in machine learning and formal languages determines if a model or automaton generates the empty language, which is undecidable for certain alternating multi-head finite automata over single-letter alphabets.
+The emptiness problem is undecidable for context-sensitive grammars, a fact that follows from the undecidability of the halting problem. It is, however, decidable for context-free grammars.
+
+
+== See also ==
+Intersection non-emptiness problem
+
+
+== References ==

data/en.wikipedia.org/wiki/Encompassment_ordering-0.md

@@ -0,0 +1,29 @@
+---
+title: "Encompassment ordering"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Encompassment_ordering"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:33:08.154025+00:00"
+instance: "kb-cron"
+---
+
+In theoretical computer science, in particular in automated theorem proving and term rewriting,
+the containment, or encompassment, preorder (≤) on the set of terms, is defined by
+
+s ≤ t if a subterm of t is a substitution instance of s.
+It is used e.g. in the Knuth–Bendix completion algorithm.
+
+
+== Properties ==
+Encompassment is a preorder, i.e. reflexive and transitive, but not anti-symmetric, nor total
+The corresponding equivalence relation, defined by s ~ t if s ≤ t ≤ s, is equality modulo renaming.
+s ≤ t whenever s is a subterm of t.
+s ≤ t whenever t is a substitution instance of s.
+The union of any well-founded rewrite order R with (<) is well-founded, where (<) denotes the irreflexive kernel of (≤). In particular, (<) itself is well-founded.
+
+
+== Notes ==
+
+
+== References ==

data/en.wikipedia.org/wiki/Encrypted_function-0.md

@@ -0,0 +1,29 @@
+---
+title: "Encrypted function"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Encrypted_function"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:33:09.347330+00:00"
+instance: "kb-cron"
+---
+
+An encrypted function is an attempt to provide mobile code privacy without providing any tamper-resistant hardware. It is a method where in mobile code can carry out cryptographic primitives. 
+Polynomial and rational functions are encrypted such that their transformation can again be implemented, as programs consisting of cleartext instructions that a processor or interpreter understands. The processor would not understand the program's function. This field of study is gaining popularity as mobile cryptography.
+
+
+== Example ==
+Scenario: 
+Host A, has an algorithm which computes function f. A wants to send its mobile agent to B which holds input x, to compute f(x). But A doesn't want B to learn anything about f.
+Scheme:
+Function f is encrypted in a way that results in E(f). Host A then creates another program P(E(f)), which implements E(f), and sends it to B through its agent. B then runs the agent, which computes P(E(f))(x) and returns the result to A. A then decrypts this to get f(x).
+Drawbacks:
+Finding appropriate encryption schemes that can transform arbitrary functions is a challenge. The scheme doesn't prevent denial of service, replay, experimental extraction and others.
+
+
+== See also ==
+Homomorphic encryption
+
+
+== References ==
+Thomas Sander and Christian F. Tschudin. Protecting Mobile Agents Against Malicious Hosts. In G. Vigna, editor, Mobile agents and security, volume 1419 of Lecture Notes in Computer Science, pages 44–60. Springer-Verlag, New York, NY, 1998. [1]

data/en.wikipedia.org/wiki/Energy_informatics-0.md

@@ -0,0 +1,23 @@
+---
+title: "Energy informatics"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Energy_informatics"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:33:10.500826+00:00"
+instance: "kb-cron"
+---
+
+Energy informatics is a research field covering the use of information and communication technology to address energy utilization and management challenges. Methods used for "smart" implementations often combine IoT sensors with artificial intelligence and machine learning. Energy Informatics is founded on flow networks that are the major suppliers and consumers of energy. Their efficiency  can be improved by collecting and analyzing  information.
+
+
+== Application areas ==
+The field among other consider application areas within:
+
+Smart Buildings by developing ICT-centred solutions for improving the energy-efficiency of buildings.
+Smart Cities by investigating the synergies between demand patterns and supply availability of energy flows in cities and communities to improve energy efficiency, increase integration of renewable sources, and provide resilience towards system faults caused by extreme situations, like hurricanes and flooding.
+Smart Industries including the development of ICT-centred solutions for improving the energy efficiency and predictability of energy intensive industrial processes, without compromising process and product quality.
+Smart Energy Networks by developing ICT-centred solutions for coordinating the supply and demand in environmentally sustainable energy networks.
+
+
+== References ==

data/en.wikipedia.org/wiki/Engine_(computer_science)-0.md

@@ -0,0 +1,14 @@
+---
+title: "Engine (computer science)"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Engine_(computer_science)"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:33:11.691264+00:00"
+instance: "kb-cron"
+---
+
+An engine is a continuation-based construct that provides timed preemption. Engines which can contain other engines are sometimes called Nesters and engines which do not have this ability are then called flat engines or "solo engines". To implement timed preemption there needs to be a clock. This clock can measure real time or simulated time. Simulated time can be implemented in a language like  Scheme, by making each function start with decrementing the clock.
+
+
+== References ==

data/en.wikipedia.org/wiki/Enterprise_data_modelling-0.md

@@ -0,0 +1,23 @@
+---
+title: "Enterprise data modelling"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Enterprise_data_modelling"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:33:12.897705+00:00"
+instance: "kb-cron"
+---
+
+Enterprise data modelling or enterprise data modeling (EDM) is the practice of creating a graphical model of the data used by an enterprise or company. Typical outputs of this activity include an enterprise data model consisting of entity–relationship diagrams (ERDs), XML schemas (XSD), and an enterprise wide data dictionary.
+
+
+== Overview ==
+Producing such a model allows for a business to get a 'helicopter' view of their enterprise. In EAI (enterprise application integration) an EDM allows data to be represented in a single idiom, enabling the use of a common syntax for the XML of services or operations and the physical data model for database schema creation. Data modeling tools for ERDs that also allow the user to create a data dictionary are usually used to aid in the development of an EDM. 
+The implementation of an EDM is closely related to the issues of data governance and data stewardship within an organization.
+
+ An Enterprise Data Model (EDM) represents a single integrated definition of data, unbiased of any system or application. It is independent of “how” the data is physically sourced, stored, processed or accessed. The model unites, formalizes and represents the things important to an organization, as well as the rules governing them
+
+
+== References ==
+Noreen Kendle (July 1, 2005). "The Enterprise Data Model". The Data Administration Newsletter.
+Andy Graham (2010). The Enterprise Data Model: A framework for enterprise data architecture. ISBN 978-0956582904.

data/en.wikipedia.org/wiki/Epitome_(data_processing)-0.md

@@ -0,0 +1,21 @@
+---
+title: "Epitome (data processing)"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Epitome_(data_processing)"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:33:15.234080+00:00"
+instance: "kb-cron"
+---
+
+An epitome, in data processing, is a condensed digital representation of the essential statistical properties of ordered datasets such as matrices that represent images, audio signals, videos or genetic sequences. Although much smaller than the data, the epitome contains many of its smaller overlapping parts with much less repetition and with some level of generalization. As such, it can be used in tasks such as data mining, machine learning and signal processing.
+The first use of epitomic analysis was with image textures for the purposes of image parsing. Epitomes have also been used in video processing to replace, remove or superresolve imagery.
+Epitomes are also being investigated as tools for vaccine design.
+
+
+== See also ==
+Image processing
+Video imprint (computer vision)
+
+
+== References ==

data/en.wikipedia.org/wiki/Equivalence_problem-0.md

@@ -0,0 +1,18 @@
+---
+title: "Equivalence problem"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Equivalence_problem"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:33:16.447919+00:00"
+instance: "kb-cron"
+---
+
+In theoretical computer science and formal language theory, the equivalence problem is the question of determining, given two representations of formal languages, whether they denote the same formal language. 
+The complexity and decidability of this decision problem depend upon the type of representation under consideration.
+For instance, in the case of finite-state automata, equivalence is decidable, and the problem is PSPACE-complete.
+Further, in the case of deterministic pushdown automata, equivalence is decidable, Géraud Sénizergues won the Gödel Prize for this result. Subsequently, the problem was shown to lie in TOWER, the least non-elementary complexity class.
+It becomes an undecidable problem for pushdown automata or any machine that can decide context-free languages or more powerful languages.
+
+
+== References ==

data/en.wikipedia.org/wiki/Error_floor-0.md

@@ -0,0 +1,15 @@
+---
+title: "Error floor"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Error_floor"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:33:17.647448+00:00"
+instance: "kb-cron"
+---
+
+The error floor is a phenomenon encountered in modern iterated sparse graph-based error correcting codes like LDPC codes and turbo codes. When the bit error ratio (BER) is plotted for conventional codes like Reed–Solomon codes under algebraic decoding or for convolutional codes under Viterbi decoding, the BER steadily decreases in the form of a curve as the SNR condition becomes better. For LDPC codes and turbo codes there is a point after which the curve does not fall as quickly as before, in other words, there is a region in which performance flattens. This region is called the error floor region. The region just before the sudden drop in performance is called the waterfall region.
+Error floors are usually attributed to low-weight codewords (in the case of Turbo codes) and trapping sets or near-codewords (in the case of LDPC codes).
+
+
+== References ==

data/en.wikipedia.org/wiki/Evolutionary_programming-0.md

@@ -0,0 +1,50 @@
+---
+title: "Evolutionary programming"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Evolutionary_programming"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:33:18.863515+00:00"
+instance: "kb-cron"
+---
+
+Evolutionary programming is an evolutionary algorithm, where a share of new population is created by mutation of previous population without crossover. Evolutionary programming differs from evolution strategy ES(
+  
+    
+      
+        μ
+        +
+        λ
+      
+    
+    {\displaystyle \mu +\lambda }
+  
+) in one detail. All individuals are selected for the new population, while in ES(
+  
+    
+      
+        μ
+        +
+        λ
+      
+    
+    {\displaystyle \mu +\lambda }
+  
+), every individual has the same probability to be selected. It is one of the four major evolutionary algorithm paradigms.
+
+
+== History ==
+It was first used by Lawrence J. Fogel in the US in 1960 in order to use simulated evolution as a learning process aiming to generate artificial intelligence. It was used to evolve finite-state machines as predictors.
+
+
+== See also ==
+Genetic algorithm
+Genetic operator
+
+
+== References ==
+
+
+== External links ==
+The Hitch-Hiker's Guide to Evolutionary Computation: What's Evolutionary Programming (EP)?
+Evolutionary Programming by Jason Brownlee (PhD) Archived 2013-01-18 at the Wayback Machine

data/en.wikipedia.org/wiki/Phil_Bagwell-0.md

@@ -0,0 +1,23 @@
+---
+title: "Phil Bagwell"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Phil_Bagwell"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:31:20.991909+00:00"
+instance: "kb-cron"
+---
+
+Phil Bagwell (died 6 October 2012) was a computer scientist known for his work and influence in the area of persistent data structures. He is best known for his 2000 invention of hash array mapped tries.
+Bagwell was probably the most influential researcher in the field of persistent data structures from 2000 until his death. His work is now a standard part of the runtimes of functional programming languages including Clojure, Scala, and Haskell.
+His contributions to building the Scala community are remembered in the Phil Bagwell Memorial Scala Community Award.
+
+
+== Publications ==
+"Ideal Hash Trees" (2000), EPFL Technical Report
+"Fast Functional Lists, Hash-Lists, Deques and Variable Length Arrays" (2002), EPFL Technical Report
+"RRB Vector: A Practical General Purpose Immutable Sequence" (published posthumously in 2015) with Nicolas Stucki, Tiark Rompf, and Vlad Ureche, ICFP 2015
+"RRB-Trees: Efficient Immutable Vectors" (2012) with Tiark Rompf, EPFL Technical Report
+
+
+== References ==