diff --git a/_index.db b/_index.db
index 1e8e91c85..1dc2fbdc1 100644
Binary files a/_index.db and b/_index.db differ
diff --git a/data/en.wikipedia.org/wiki/LINDO-0.md b/data/en.wikipedia.org/wiki/LINDO-0.md
new file mode 100644
index 000000000..0eec0640a
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/LINDO-0.md
@@ -0,0 +1,35 @@
+---
+title: "LINDO"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/LINDO"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:31.759037+00:00"
+instance: "kb-cron"
+---
+
+LINDO (Linear, Interactive, and Discrete Optimizer) is a software package for linear programming, integer programming, nonlinear programming, stochastic programming and global optimization.
+LINGO is a mathematical modeling language used as part of LINDO.
+Today, LINDO solvers are part of LINDO API (Application Programming Interface) a set of software libraries that can be called from different programming languages to create custom mathematical optimization applications.
+It is designed to solve optimization problems that arise in areas of business, industry, research, and government. The LINDO package includes sample applications related to product distribution, ingredient blending, production, personnel scheduling, inventory management.
+LINDO also creates "What'sBest!" which is an add-in for linear, integer and nonlinear optimization. First released for Lotus 1-2-3 and later also for Microsoft Excel.
+
+
+== Features ==
+LINDO provides routines to formulate, solve, query, and modify optimization problems.
+It works with programming languages including C, C++, Java, Visual Basic, .NET, Delphi, Python, and R.
+Coupled with R’s extensive statistical and data-mining tools, the LINDO API's R interface offers seamless possibilities in statistical analysis and optimization.
+LINDO solvers can also be called from MATLAB.  
+The LINDO package contains Stochastic, Linear, Nonlinear (convex & nonconvex/Global), Quadratic, Quadratically Constrained, Second Order Cone and Integer solvers.
+It provides tools for analysis of infeasible linear, integer and nonlinear models.
+LINDO supports Multiple Objective Optimization. For linear models, users can provide a prioritized list of objective functions, and LINDO will perform Lexico/Pre-emptive priority optimization.
+The Multi-Start NLP Solver in LINDO makes it possible for users to specify a target value for the objective function. As soon as any multi-start thread achieves a specified target all threads stop.
+With the release of LINDO API 7.0, LINDO stochastic functionality allows users to incorporate uncertainty into their models.
+In 2012, LINDO brings multicore processors support to increase solve speed.
+
+
+== References ==
+
+
+== External links ==
+Official website [1]
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/LOM_port-0.md b/data/en.wikipedia.org/wiki/LOM_port-0.md
new file mode 100644
index 000000000..c86fa2e5e
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/LOM_port-0.md
@@ -0,0 +1,33 @@
+---
+title: "LOM port"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/LOM_port"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:35:58.071889+00:00"
+instance: "kb-cron"
+---
+
+The LOM port (Lights Out Management port) is a remote access facility on a Sun Microsystems server.  When the main processor is switched off, or when it is impossible to telnet to the server, an operator would use a link to the LOM port to access the server. As long as the server has power, the LOM facility will work, regardless of whether or not the main processor is switched on.
+To use the LOM port, a rollover cable or nullmodem serial DB9 cable on some models is connected to the LOM port, which is located at the back of the Sun server. The other end of the cable is connected to a terminal or a PC running a terminal emulator. The terminal or emulator must be set to a transmission rate of 9600 bits per second, and hardware flow control enabled.
+
+
+== Implementations ==
+Specific implementations include:
+
+Advanced Lights Out Management (ALOM), Sun Microsystems-specific and comes standard on newer Sun servers (SunFire V125/V210/V215/V240/V245/V250/V440/T1000/T2000, Sun Netra 210/240/440).
+Integrated Lights Out Management (ILOM), Sun Microsystems's ALOM replacement on Sun x64 server SunFire X4100(M2)/X4200(M2)/X4600(M2)/X4140/X4240/X4440/X4150/X4250/X4450/X4170/X4270/X2250/X2270, Sun Blade 6000 Chassis Management Module/Blade Module(X6220/X6420/X6240/X6440/X6250/X6450/X6270/X6275), Sun CMT servers/blades (Sun T5120, T5220, T5240, T6340, T6320). Not to be confused with the similar-sounding HP Integrated Lights-Out management technology.
+Lomlite and Lomlite2 Single-chip implementations on the Netra T1 and possibly others. In the cases of the T1-200 and X1, the OpenBoot firmware implements lom@ and lom! commands allowing access to the registers representing temperature, voltage, etc.
+
+
+== See also ==
+
+Out-of-band management
+Power distribution unit
+
+
+== References ==
+
+
+== External links ==
+Netra-T1 AC200 LOM Usage
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/LZRW-0.md b/data/en.wikipedia.org/wiki/LZRW-0.md
new file mode 100644
index 000000000..0f86c8127
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/LZRW-0.md
@@ -0,0 +1,24 @@
+---
+title: "LZRW"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/LZRW"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:00.495178+00:00"
+instance: "kb-cron"
+---
+
+Lempel–Ziv Ross Williams (LZRW) refers to variants of the LZ77 lossless data compression algorithms with an emphasis on improving compression speed through the use of hash tables and other techniques.  This family was explored by Ross Williams, who published a series of algorithms beginning with LZRW1 in 1991.
+The variants are:
+
+LZRW1
+LZRW1-A
+LZRW2
+LZRW3
+LZRW3-A
+LZRW4
+LZRW5
+The LZJB algorithm used in ZFS is derived from LZRW1.
+
+
+== Notes ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Local_ternary_patterns-0.md b/data/en.wikipedia.org/wiki/Local_ternary_patterns-0.md
new file mode 100644
index 000000000..3f79225c1
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Local_ternary_patterns-0.md
@@ -0,0 +1,92 @@
+---
+title: "Local ternary patterns"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Local_ternary_patterns"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:35:53.332732+00:00"
+instance: "kb-cron"
+---
+
+Local ternary patterns (LTP) are an extension of local binary patterns (LBP). Unlike LBP, it does not threshold the pixels into 0 and 1, rather it uses a threshold constant to threshold pixels into three values. Considering k as the threshold constant, c as the value of the center pixel, a neighboring pixel p, the result of threshold is:
+
+  
+    
+      
+        
+          
+            {
+            
+              
+                
+                  1
+                  ,
+                
+                
+                  
+                    if 
+                  
+                  p
+                  >
+                  c
+                  +
+                  k
+                
+              
+              
+                
+                  0
+                  ,
+                
+                
+                  
+                    if 
+                  
+                  p
+                  >
+                  c
+                  −
+                  k
+                  
+                     and 
+                  
+                  p
+                  <
+                  c
+                  +
+                  k
+                
+              
+              
+                
+                  −
+                  1
+                
+                
+                  
+                    if 
+                  
+                  p
+                  <
+                  c
+                  −
+                  k
+                
+              
+            
+            
+          
+        
+      
+    
+    {\displaystyle {\begin{cases}1,&{\text{if }}p>c+k\\0,&{\text{if }}p>c-k{\text{ and }}p<c+k\\-1&{\text{if }}p<c-k\\\end{cases}}}
+  
+
+In this way, each thresholded pixel has one of the three values. Neighboring pixels are combined after thresholding into a ternary pattern. Computing a histogram of these ternary values will result in a large range, so the ternary pattern is split into two binary patterns. Histograms are concatenated to generate a descriptor double the size of LBP.
+
+
+== See also ==
+Local binary patterns
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/LogP_machine-0.md b/data/en.wikipedia.org/wiki/LogP_machine-0.md
new file mode 100644
index 000000000..3f2665d87
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/LogP_machine-0.md
@@ -0,0 +1,132 @@
+---
+title: "LogP machine"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/LogP_machine"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:35:56.848173+00:00"
+instance: "kb-cron"
+---
+
+The LogP machine is a model for parallel computation.
+It aims at being more practical than the PRAM model while still allowing for easy analysis of computation.
+The name is not related to the mathematical logarithmic function:  Instead, the machine is described by the four parameters 
+  
+    
+      
+        L
+      
+    
+    {\displaystyle L}
+  
+, 
+  
+    
+      
+        o
+      
+    
+    {\displaystyle o}
+  
+, 
+  
+    
+      
+        g
+      
+    
+    {\displaystyle g}
+  
+ and 
+  
+    
+      
+        P
+      
+    
+    {\displaystyle P}
+  
+.
+The LogP machine consists of arbitrarily many processing units with distributed memory.
+The processing units are connected through an abstract communication medium which allows point-to-point communication. This model is pair-wise synchronous and overall asynchronous.
+The machine is described by the four parameters:
+
+  
+    
+      
+        L
+      
+    
+    {\displaystyle L}
+  
+, the latency of the communication medium.
+
+  
+    
+      
+        o
+      
+    
+    {\displaystyle o}
+  
+, the overhead of sending and receiving a message.
+
+  
+    
+      
+        g
+      
+    
+    {\displaystyle g}
+  
+, the gap required between two send/receive operations. A more common interpretation of this quantity is as the inverse of the bandwidth of a processor-processor communication channel.
+
+  
+    
+      
+        P
+      
+    
+    {\displaystyle P}
+  
+, the number of processing units.
+Each local operation on each machine takes the same time ('unit time').  This time is called a processor cycle. The units of the parameters 
+  
+    
+      
+        L
+      
+    
+    {\displaystyle L}
+  
+, 
+  
+    
+      
+        o
+      
+    
+    {\displaystyle o}
+  
+ and 
+  
+    
+      
+        g
+      
+    
+    {\displaystyle g}
+  
+ are measured in multiples of processor cycles.
+
+
+== See also ==
+Bulk synchronous parallel
+Parallel programming model
+
+
+== Notes ==
+
+
+== References ==
+Culler, David; Karp, Richard; Patterson, David; Sahay, Abhijit; Schauser, Klaus Erik; Santos, Eunice; Subramonian, Ramesh; Von Eicken, Thorsten (July 1993), "LogP: Towards a realistic model of parallel computation", ACM SIGPLAN Notices, 28 (7): 1–12, CiteSeerX 10.1.1.319.7827, doi:10.1145/173284.155333
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Log_management_knowledge_base-0.md b/data/en.wikipedia.org/wiki/Log_management_knowledge_base-0.md
new file mode 100644
index 000000000..40b0fff73
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Log_management_knowledge_base-0.md
@@ -0,0 +1,25 @@
+---
+title: "Log management knowledge base"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Log_management_knowledge_base"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:35:54.491277+00:00"
+instance: "kb-cron"
+---
+
+The Log Management Knowledge Base is a free database of detailed descriptions on over 20,000 event logs generated by Windows systems, syslog devices and applications. Provided as a free service to the IT community by Prism Microsystems, the aim of the Knowledge Base is to help IT personnel make sense of the large amounts of cryptic and arcane log data generated by network systems and IT infrastructures.
+Log data provides a record of all corporate system activity and is critical for improving security, complying with requirements such as Sarbanes-Oxley, HIPAA and PCI-DSS, and optimizing IT operations. However, given the large number of logs produced by different devices, their inherent obscurity and the lack of a standard logging format, system-specific expertise is typically needed to extract any meaningful intelligence.
+The Knowledge Base provides this expertise free of charge via a searchable web repository with the aim of making log data readily understandable by all. The Knowledge Base can be searched using any combination of event log ID, source or fragments of the description field. Advanced search options are available as well
+
+
+== See also ==
+System administration
+Log management and intelligence
+
+
+== References ==
+
+
+== External links ==
+Knowledge Base EventTracker Knowledge Base
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Logic_of_Computable_Functions-0.md b/data/en.wikipedia.org/wiki/Logic_of_Computable_Functions-0.md
new file mode 100644
index 000000000..f19a6e321
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Logic_of_Computable_Functions-0.md
@@ -0,0 +1,17 @@
+---
+title: "Logic of Computable Functions"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Logic_of_Computable_Functions"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:35:55.676880+00:00"
+instance: "kb-cron"
+---
+
+Logic of Computable Functions (LCF) is a deductive system for computable functions proposed by Dana Scott in 1969 in a memorandum unpublished until 1993. It inspired:
+
+Logic for Computable Functions (LCF), theorem proving logic by Robin Milner.
+Programming Computable Functions (PCF), small theoretical programming language by Gordon Plotkin.
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Lossy_Count_Algorithm-0.md b/data/en.wikipedia.org/wiki/Lossy_Count_Algorithm-0.md
new file mode 100644
index 000000000..0e412e445
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Lossy_Count_Algorithm-0.md
@@ -0,0 +1,56 @@
+---
+title: "Lossy Count Algorithm"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Lossy_Count_Algorithm"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:35:59.259838+00:00"
+instance: "kb-cron"
+---
+
+The lossy count algorithm is an algorithm to identify elements in a data stream whose frequency exceeds a user-given threshold. The algorithm works by dividing the data stream into buckets for frequent items, but fill as many buckets as possible in main memory one time. The frequency computed by this algorithm is not always accurate, but has an error threshold that can be specified by the user. The run time and space required by the algorithm is inversely proportional to the specified error threshold; hence the larger the error, the smaller the footprint. 
+The algorithm was created by computer scientists Rajeev Motwani and Gurmeet Singh Manku. It finds applications in computations where data takes the form of a continuous data stream instead of a finite data set, such as network traffic measurements, web server logs, and clickstreams.
+
+
+== Algorithm ==
+The general algorithm is as follows
+
+Step 1: Divide the incoming data stream into buckets of width 
+  
+    
+      
+        w
+        =
+        1
+        
+          /
+        
+        ϵ
+      
+    
+    {\displaystyle w=1/\epsilon }
+  
+, where 
+  
+    
+      
+        ϵ
+      
+    
+    {\displaystyle \epsilon }
+  
+ is mentioned by user as the error bound (along with minimum support threshold = 
+  
+    
+      
+        σ
+      
+    
+    {\displaystyle \sigma }
+  
+).
+Step 2: Increment the frequency count of each item according to the new bucket values. After each bucket, decrement all counters by 1.
+Step 3: Repeat – Update counters and after each bucket, decrement all counters by 1.
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/MIT_Media_Lab_Object-Based_Media-0.md b/data/en.wikipedia.org/wiki/MIT_Media_Lab_Object-Based_Media-0.md
new file mode 100644
index 000000000..db0ab8f14
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/MIT_Media_Lab_Object-Based_Media-0.md
@@ -0,0 +1,20 @@
+---
+title: "MIT Media Lab Object-Based Media"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/MIT_Media_Lab_Object-Based_Media"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:24.542834+00:00"
+instance: "kb-cron"
+---
+
+The Object-Based Media Group at the MIT Media Lab, formerly led by V. Michael Bove, Jr., explored the creative and technological applications and implications of the intersection of context-aware consumer electronics and self-aware digital content. Projects included immersive, interactive, and personalized television, 3-D display technologies (in particular computer generated holography), novel user interfaces, and applications that run on ecosystems of consumer electronics devices. Graduate students in the group typically had backgrounds in signal processing and understanding, image capture and display (especially in 3-D), user interfaces, technical and creative aspects of new media forms, and/or consumer electronics product design.
+Bove was ousted in a #MeToo incident in the fall of 2019.
+
+
+== References ==
+
+
+== External links ==
+Object-Based Media Group Overview Webpage
+Archive of group web site
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/MOSEK-0.md b/data/en.wikipedia.org/wiki/MOSEK-0.md
new file mode 100644
index 000000000..af1fb7982
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/MOSEK-0.md
@@ -0,0 +1,23 @@
+---
+title: "MOSEK"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/MOSEK"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:33.005173+00:00"
+instance: "kb-cron"
+---
+
+MOSEK is a software package for the solution of linear, mixed-integer linear, quadratic, mixed-integer quadratic, quadratically constrained, conic and convex nonlinear mathematical optimization problems. The applicability of the solver varies widely and is commonly used for solving problems in areas such as engineering, finance and computer science.
+The emphasis in MOSEK is on solving large-scale sparse problems linear and conic optimization problems. In particular, MOSEK solves conic quadratic (a.k.a. Second-order cone programming) and semi-definite (aka. semidefinite programming) problems.
+A special feature of the solver, is its interior-point optimizer, based on the so-called homogeneous model. This implies that MOSEK can reliably detect a primal and/or dual infeasible status as documented in several published papers.
+In addition to the interior-point optimizer MOSEK includes:
+
+Primal and dual simplex optimizer for linear problems.
+Mixed-integer optimizer for linear, quadratic and conic problems.
+In version 9, Mosek introduced support for exponential and power cones in its solver. It has interfaces to the C, C#, Java, MATLAB, Python and R languages. Major modeling systems are made compatible with MOSEK, examples are: AMPL,  GAMS and CVXPY. In 2020 the solver also became available in Wolfram Mathematica.
+In addition, Mosek can for instance be used with the popular MATLAB packages CVX, and YALMIP.
+The MOSEK software was developed by Mosek ApS, a Danish company established in 1997 by Erling D. Andersen. The headquarter of Mosek is located in Copenhagen, the capital of Denmark.
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Mahaney's_theorem-0.md b/data/en.wikipedia.org/wiki/Mahaney's_theorem-0.md
new file mode 100644
index 000000000..605c8fd3c
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Mahaney's_theorem-0.md
@@ -0,0 +1,52 @@
+---
+title: "Mahaney's theorem"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Mahaney's_theorem"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:01.684686+00:00"
+instance: "kb-cron"
+---
+
+Mahaney's theorem is a theorem in computational complexity theory proven by Stephen Mahaney that states thatIf any sparse language is NP-hard, then P=NP.Note that the existence of an NP-hard sparse set implies the existence of an NP-complete sparse set.
+Mahaney's theorem was motivated by the Berman–Hartmanis conjectureGiven any two NP-complete sets 
+  
+    
+      
+        A
+        ,
+        B
+      
+    
+    {\displaystyle A,B}
+  
+, there exists a pair of functions 
+  
+    
+      
+        f
+        :
+        A
+        →
+        B
+        ,
+        
+          f
+          
+            −
+            1
+          
+        
+        :
+        B
+        →
+        A
+      
+    
+    {\displaystyle f:A\to B,f^{-1}:B\to A}
+  
+ that are mutual inverses of each other, and are computable in polynomial time. Since we know that some NP-complete sets are not sparse (for example, the set of satisfiable 3SAT formulas), Berman and Hartmanis derived a second, weaker conjecture:There are no NP-complete sparse sets.Mahaney's result shows that, if P≠NP, then indeed there are no NP-complete sparse sets, thus settling the second conjecture under the standard assumption of P≠NP.
+The result was strengthened in 1991 to state that:If there exists a sparse language, such that a polynomial-time algorithm exists to solve the SAT problem by making O(1) queries to the sparse language oracle, then P=NP.This is stronger than Mahaney's theorem, which is the special case where the polynomial-time algorithm can make at most 1 query to the sparse language protocol.
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/MailSlot-0.md b/data/en.wikipedia.org/wiki/MailSlot-0.md
new file mode 100644
index 000000000..7c32cb460
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/MailSlot-0.md
@@ -0,0 +1,38 @@
+---
+title: "MailSlot"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/MailSlot"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:02.862846+00:00"
+instance: "kb-cron"
+---
+
+Mailslot is a one-way interprocess communication mechanism, available on the Microsoft Windows operating system that allows communication between processes locally. Up until Window 11 24H2, mailslots also supported communication over a network . The use of Mailslots is generally simpler than named pipes or sockets when a relatively small number of relatively short messages is expected to be transmitted, such as for example infrequent state-change messages, or as part of a peer-discovery protocol. Up until Windows 11 24H2, the Mailslot mechanism also allowed for short message broadcasts ("datagrams") to all listening computers across a given network domain.
+
+
+== Features ==
+Mailslots function as a server-client interface. A server can create a Mailslot, and a client could write to it by name. Only the server can read the mailslot, as such mailslots represented a one-way communication mechanism. A server-client interface could consist of two processes communicating locally or across a network. Mailslots operated over the RPC protocol and worked across all computers in the same network domain. Mailslots offered no confirmation that a message had been received. Mailslots were generally a good choice when one client process need to broadcast a message to multiple server processes.
+
+
+== Uses ==
+The most widely known use of the Mailslot IPC mechanism was the Windows Messenger service that was part of the Windows NT-line of products, including Windows XP. The Messenger Service, not to be confused with the MSN Messenger internet chat service, was essentially a Mailslot server that waited for a message to arrive. When a message arrived, it was displayed in a popup onscreen. The NET SEND command was therefore a type of Mailslot client, because it wrote to specified mailslots on a network.
+A number of programs also used Mailslots to communicate. Generally these were amateur chat clients and other such programs. Commercial programs usually preferred pipes or sockets.
+Mailslots were implemented as files in a mailslot file system (MSFS). Examples of Mailslots included:
+
+MAILSLOT\Messngr - Microsoft NET SEND Protocol
+MAILSLOT\Browse - Microsoft Browser Protocol
+MAILSLOT\Alerter
+MAILSLOT\53cb31a0\UnimodemNotifyTSP
+MAILSLOT\HydraLsServer - Microsoft Terminal Services Licensing
+MAILSLOT\CheyenneDS - CA BrightStor Discovery Service
+
+
+== References ==
+
+
+== External links ==
+Mailslots (MSDN Documentation)
+Using Mailslots for Interprocess Communication
+Using a Mailslot to read/write data over a network
+The beginning of the end of Remote Mailslots
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Makespan-0.md b/data/en.wikipedia.org/wiki/Makespan-0.md
new file mode 100644
index 000000000..8a956ac54
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Makespan-0.md
@@ -0,0 +1,32 @@
+---
+title: "Makespan"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Makespan"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:04.078100+00:00"
+instance: "kb-cron"
+---
+
+In operations research, the makespan of a project is the length of time that elapses from the start of work to the end. This type of multi-mode resource constrained project scheduling problem (MRCPSP) seeks to create the shortest logical project schedule, by efficiently using project resources, adding the lowest number of additional resources as possible to achieve the minimum makespan. The term commonly appears in the context of scheduling.
+
+
+== Example ==
+There is a complex project that is composed of several sub-tasks. We would like to assign tasks to workers, such that the project finishes in the shortest possible time. As an example, suppose the "project" is to feed the goats. There are three goats to feed, one child can only feed one goat at a time, and there are two children that can feed them: Shmuel feeds each goat in 10 minutes and Shifra feeds each goat in 12 minutes. Several schedules are possible:
+
+If we let Shmuel feed all goats, then the makespan is 30 (3×10 for Shmuel, 0 for Shifra);
+If we let Shifra feed one goat and Shmuel two goats, then the makespan is 20 (2×10 for Shmuel, 12 for Shifra working beside and in parallel to Shmuel);
+If we let Shifra feed two goats and Shmuel one goat, then the makespan is 24 (2×12 for Shifra, 10 for Samuel working beside and in parallel to Shifra);
+If we let Shifra feed all goats, then the makespan is 36 (3×12 for Shifra, 0 for Shmuel).
+So in this case, the second schedule attains the shortest makespan, which is 20.
+
+
+== Types of makespan minimization problems ==
+Johnson's Rule – there are n jobs and 2 different stations. Consider using this rule to sequence jobs that must go through both work centers.
+Job shop scheduling – there are n jobs and m identical stations. Each job should be executed on a single station. This is usually regarded as an online problem.
+Open-shop scheduling – there are n jobs and m different stations. Each job should spend some time at each station, in a free order.
+Flow shop scheduling – there are n jobs and m different stations. Each job should spend some time at each station, in a pre-determined order.
+Fair makespan minimization - When assigning tasks to agents, it is required both to minimize the makespan, and to avoid envy. If the fastest worker is given a job, he has to be compensated for his extra effort. Mu'alem presents a general framework for optimization problems with envy-freeness guarantee using monetary payments.
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Mark_and_space-0.md b/data/en.wikipedia.org/wiki/Mark_and_space-0.md
new file mode 100644
index 000000000..dbae8e005
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Mark_and_space-0.md
@@ -0,0 +1,23 @@
+---
+title: "Mark and space"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Mark_and_space"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:05.237356+00:00"
+instance: "kb-cron"
+---
+
+Mark and space are terms used in telecommunications to describe two different signal states of a communications signal, generally at the physical layer of a communications system. The terms derive from the early days of the electric telegraph system, where the marking state would cause a mark to be output on paper, and the spacing state would create no mark.
+
+The terms would continue to be used in systems such as RS-232, with similar conventions, that "mark" would be encoded by a negative voltage (or current flow), and "space" by a positive voltage (or no current flow). In such systems, the line is typically left in the "mark" state when idle.
+"Mark" is generally identified with the binary digit "1" and "space" with the binary digit "0".
+
+
+== See also ==
+Baud
+Break key
+Morse code
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Matrix_clock-0.md b/data/en.wikipedia.org/wiki/Matrix_clock-0.md
new file mode 100644
index 000000000..f4a80a7f9
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Matrix_clock-0.md
@@ -0,0 +1,23 @@
+---
+title: "Matrix clock"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Matrix_clock"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:06.460710+00:00"
+instance: "kb-cron"
+---
+
+A matrix clock is a mechanism for capturing chronological and causal relationships in a distributed system.
+Matrix clocks are a generalization of the notion of vector clocks. A matrix clock maintains a vector of the vector clocks for each communicating host.
+Every time a message is exchanged, the sending host sends not only what it knows about the global state of time, but also the state of time that it received from other hosts.
+This allows establishing a lower bound on what other hosts know, and is useful in applications such as checkpointing and garbage collection.
+
+
+== References ==
+
+
+== See also ==
+Lamport timestamps
+Vector clock
+Version vector
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Matrix_mortality_problem-0.md b/data/en.wikipedia.org/wiki/Matrix_mortality_problem-0.md
index 0ffae239e..2a64a5064 100644
--- a/data/en.wikipedia.org/wiki/Matrix_mortality_problem-0.md
+++ b/data/en.wikipedia.org/wiki/Matrix_mortality_problem-0.md
@@ -4,7 +4,7 @@ chunk: 1/1
 source: "https://en.wikipedia.org/wiki/Matrix_mortality_problem"
 category: "reference"
 tags: "science, encyclopedia"
-date_saved: "2026-05-05T11:03:32.800214+00:00"
+date_saved: "2026-05-05T11:36:07.717257+00:00"
 instance: "kb-cron"
 ---
 
diff --git a/data/en.wikipedia.org/wiki/Maximal_pair-0.md b/data/en.wikipedia.org/wiki/Maximal_pair-0.md
new file mode 100644
index 000000000..e066365c4
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Maximal_pair-0.md
@@ -0,0 +1,294 @@
+---
+title: "Maximal pair"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Maximal_pair"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:08.929308+00:00"
+instance: "kb-cron"
+---
+
+In computer science, a maximal pair within a string is a pair of matching substrings that are maximal, where "maximal" means that it is not possible to make a longer matching pair by extending the range of both substrings to the left or right.
+
+
+== Example ==
+
+For example, in this table, the substrings at indices 2 to 4 (in red) and indices 6 to 8 (in blue) are a maximal pair, because they contain identical characters (abc), and they have different characters to the left (x at index 1 and y at index 5) and different characters to the right (y at index 5 and w at index 9). Similarly, the substrings at indices 6 to 8 (in blue) and indices 10 to 12 (in green) are a maximal pair.
+However, the substrings at indices 2 to 4 (in red) and indices 10 to 12 (in green) are not a maximal pair, as the character y follows both substrings, and so they can be extended to the right to make a longer pair.
+
+
+== Formal definition ==
+Formally, a maximal pair of substrings with starting positions 
+  
+    
+      
+        
+          p
+          
+            1
+          
+        
+      
+    
+    {\displaystyle p_{1}}
+  
+ and 
+  
+    
+      
+        
+          p
+          
+            2
+          
+        
+      
+    
+    {\displaystyle p_{2}}
+  
+ respectively, and both of length 
+  
+    
+      
+        l
+      
+    
+    {\displaystyle l}
+  
+, is specified by a triple 
+  
+    
+      
+        (
+        
+          p
+          
+            1
+          
+        
+        ,
+        
+          p
+          
+            2
+          
+        
+        ,
+        l
+        )
+      
+    
+    {\displaystyle (p_{1},p_{2},l)}
+  
+, such that, given a string 
+  
+    
+      
+        S
+      
+    
+    {\displaystyle S}
+  
+ of length 
+  
+    
+      
+        n
+      
+    
+    {\displaystyle n}
+  
+, 
+  
+    
+      
+        S
+        [
+        
+          p
+          
+            1
+          
+        
+        .
+        .
+        
+          p
+          
+            1
+          
+        
+        +
+        l
+        −
+        1
+        ]
+        =
+        S
+        [
+        
+          p
+          
+            2
+          
+        
+        .
+        .
+        
+          p
+          
+            2
+          
+        
+        +
+        l
+        −
+        1
+        ]
+      
+    
+    {\displaystyle S[p_{1}..p_{1}+l-1]=S[p_{2}..p_{2}+l-1]}
+  
+ (meaning that the substrings have identical contents), but 
+  
+    
+      
+        S
+        [
+        
+          p
+          
+            1
+          
+        
+        −
+        1
+        ]
+        ≠
+        S
+        [
+        
+          p
+          
+            2
+          
+        
+        −
+        1
+        ]
+      
+    
+    {\displaystyle S[p_{1}-1]\neq S[p_{2}-1]}
+  
+ (they have different characters to their left) and 
+  
+    
+      
+        S
+        [
+        
+          p
+          
+            1
+          
+        
+        +
+        l
+        ]
+        ≠
+        S
+        [
+        
+          p
+          
+            2
+          
+        
+        +
+        l
+        ]
+      
+    
+    {\displaystyle S[p_{1}+l]\neq S[p_{2}+l]}
+  
+ (they also have different characters to their right; together, these two inequalities are the condition for being maximal). Thus, in the example above, the maximal pairs are 
+  
+    
+      
+        (
+        2
+        ,
+        6
+        ,
+        3
+        )
+      
+    
+    {\displaystyle (2,6,3)}
+  
+ (the red and blue substrings) and 
+  
+    
+      
+        (
+        6
+        ,
+        10
+        ,
+        3
+        )
+      
+    
+    {\displaystyle (6,10,3)}
+  
+ (the green and blue substrings), and 
+  
+    
+      
+        (
+        2
+        ,
+        10
+        ,
+        3
+        )
+      
+    
+    {\displaystyle (2,10,3)}
+  
+ is not a maximal pair.
+
+
+== Related concepts and time complexity ==
+A maximal repeat is the string represented by a maximal pair. A supermaximal repeat is a maximal repeat never occurring as a proper substring of another maximal repeat. In the above example, abc and abcy are both maximal repeats, but only abcy is a supermaximal repeat.
+Maximal pairs, maximal repeats and supermaximal repeats can each be found in 
+  
+    
+      
+        Θ
+        (
+        n
+        +
+        z
+        )
+      
+    
+    {\displaystyle \Theta (n+z)}
+  
+ time using a suffix tree, if there are 
+  
+    
+      
+        z
+      
+    
+    {\displaystyle z}
+  
+ such structures.
+
+
+== References ==
+
+
+== External links ==
+Project for the computation of all maximal repeats in one ore more strings in Python, using suffix array.
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Memory-disk_synchronization-0.md b/data/en.wikipedia.org/wiki/Memory-disk_synchronization-0.md
new file mode 100644
index 000000000..8ea5910fa
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Memory-disk_synchronization-0.md
@@ -0,0 +1,20 @@
+---
+title: "Memory-disk synchronization"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Memory-disk_synchronization"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:14.806694+00:00"
+instance: "kb-cron"
+---
+
+Memory-disk synchronisation is a process used in computers that immediately writes to disk any data queued for writing in volatile memory.  Data is often held in this way for efficiency's sake, since writing to disk is a much slower process than writing to RAM.  Disk synchronization is needed when the computer is going to be shut down, or occasionally if a particularly important bit of data has just been written.
+In Unix-like systems, a disk synchronization may be requested by any user with the sync command.
+
+
+== See also ==
+mmap, a POSIX-compliant Unix system call that maps files or devices into memory
+msync, a POSIX-compliant Unix system call that forcefully flush memory to disk and synchronize
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Memory_ballooning-0.md b/data/en.wikipedia.org/wiki/Memory_ballooning-0.md
new file mode 100644
index 000000000..6fbfed6ac
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Memory_ballooning-0.md
@@ -0,0 +1,21 @@
+---
+title: "Memory ballooning"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Memory_ballooning"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:10.111978+00:00"
+instance: "kb-cron"
+---
+
+In computing, memory ballooning is a technique that is used to eliminate the need to overcommit host memory used by virtual machines (VMs) by letting each VM effectively "give back" unused pages of [virtual] memory.
+To implement memory ballooning, the virtual machine's kernel implements a "balloon driver" that allocates unused memory within the VM's address space into a pool of memory (the "balloon"), which makes that memory unavailable to other processes on that VM. The balloon driver doesn't use the pool of memory; instead it tells the host operating system's hypervisor which memory addresses are in that pool (unused). The host operating system then unmaps physical memory from those memory pages (with no need to copy them to secondary storage). The released pages of physical memory return to the host machine's pool of available RAM, and the host machine can use them to keep other virtual machines in physical memory and/or to cache secondary storage.
+Depending on the amount of memory required by applications running on the VM, the balloon driver inside the VM can dynamically decrease or increase the number of pages in its "balloon", causing the host computer to remap or unmap physical memory to the VM, as-needed.
+
+
+== References ==
+
+
+== See also ==
+Memory overcommitment
+Thin provisioning
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Memory_map-0.md b/data/en.wikipedia.org/wiki/Memory_map-0.md
new file mode 100644
index 000000000..a6c601553
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Memory_map-0.md
@@ -0,0 +1,37 @@
+---
+title: "Memory map"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Memory_map"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:11.290916+00:00"
+instance: "kb-cron"
+---
+
+In computer science, a memory map is a structure of data (which usually resides in memory itself) that indicates how memory is laid out. The term "memory map" has different meanings in different contexts.
+
+It is the fastest and most flexible cache organization that uses an associative memory. The associative memory stores both the address and content of the memory word.
+In the boot process of some computers, a memory map may be passed on from the firmware to instruct an operating system kernel about memory layout. It contains the information regarding the size of total memory, any reserved regions and may also provide other details specific to the architecture.
+In virtual memory implementations and memory management units, a memory map refers to page tables or hardware registers, which store the mapping between a certain process's virtual memory layout and how that space relates to physical memory addresses.
+In native debugger programs, a memory map refers to the mapping between loaded executable(or)library files and memory regions. These memory maps are used to resolve memory addresses (such as function pointers) to actual symbols.
+
+
+== PC BIOS memory map ==
+BIOS for the IBM Personal Computer and compatibles provides a set of routines that can be used by operating system or applications to get the memory layout. Some of the available routines are:
+BIOS Function: INT 0x15, AX=0xE801:
+This BIOS interrupt call is used to get the memory size for 64MB+ configurations. It is supported by AMI BIOSses dated August 23, 1994 or later. The caller sets AX to 0xE801 then executes int 0x15. If some error has happened, the routine returns with CF (Carry Flag) set to 1. If no error, the routine returns with CF clear and the state of registers is described as following:
+
+BIOS Function: INT 0x15, AX=0xE820 - GET SYSTEM MEMORY MAP:
+Input:
+
+SMAP buffer structure:
+
+How used: The operating system shall allocate an SMAP buffer in memory (20 bytes buffer). Then set registers as specified in "Input" table. On first call, EBX should be set to 0. Next step is to call INT 0x15. If no error, the interrupt call returns with CF clear and the buffer filled with data representing first region of the memory map. EBX is updated by BIOS so that when the OS calls the routine again, The next region is returned in the buffer. BIOS sets EBX to zero if all done.
+
+
+== See also ==
+BIOS
+RAMMap by Mark Russinovich
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Memory_organisation-0.md b/data/en.wikipedia.org/wiki/Memory_organisation-0.md
new file mode 100644
index 000000000..867cf69bd
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Memory_organisation-0.md
@@ -0,0 +1,40 @@
+---
+title: "Memory organisation"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Memory_organisation"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:12.484035+00:00"
+instance: "kb-cron"
+---
+
+Memory organization is an aspect of computer architecture that is concerned with the storage and transfer of data and programs.
+There are several ways to organise memories with respect to the way they are connected to the cache:
+
+one-word-wide memory organisation
+wide memory organisation
+interleaved memory organisation
+independent memory organisation
+
+
+== One-word-wide ==
+The memory is one word wide and connected via a one-word-wide bus to the cache.
+
+
+== Wide ==
+The memory is more than one word wide (usually four words wide) and connected by an equally wide bus to the low level cache (which is also wide). From the cache multiple busses of one word wide go to a MUX which selects the correct bus to connect to the high level cache.
+
+
+== Interleaved ==
+
+There are several memory banks which are one word wide, and one word wide bus. There is some logic in the memory that selects the correct bank to use when the memory gets accessed by the cache.
+Memory interleaving is a way to distribute individual addresses over memory modules. Its aim is to keep the most of modules busy as computations proceed. With memory interleaving, the low-order k bits of the memory address generally specify the module on several buses.
+
+
+== See also ==
+Cache hierarchy
+Memory hierarchy
+Memory geometry
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Memory_overcommitment-0.md b/data/en.wikipedia.org/wiki/Memory_overcommitment-0.md
new file mode 100644
index 000000000..225788082
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Memory_overcommitment-0.md
@@ -0,0 +1,19 @@
+---
+title: "Memory overcommitment"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Memory_overcommitment"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:13.608504+00:00"
+instance: "kb-cron"
+---
+
+Memory overcommitment is a concept in computing that covers the assignment of more memory to virtual computing devices (or processes) than the physical machine they are hosted, or running on, actually has. This is possible because virtual machines (or processes) do not necessarily use as much memory at any one point as they are assigned, creating a buffer. If four virtual machines each have 1 GB of memory on a physical machine with 4 GB of memory, but those virtual machines are only using 500 MB, it is possible to create additional virtual machines that take advantage of the 500 MB each existing machine is leaving free. Memory swapping is then used to handle spikes in memory usage. The disadvantage of this approach is that memory swap files are slower to read from than 'actual' memory, which can lead to performance drops. Another disadvantage is that, when running out of real memory, the system is relying on the applications to not use the additional memory despite it being allocated to them. Should a program do so anyway, it or another has to be killed in order to free up memory to prevent the system from freezing. The OOM Killer is what performs this task.
+While memory overcommitment is usually talked about in the context of virtualization, it is actually a generalised concept; Windows NT contained overcommitment features, as do most modern generalised operating systems, including the Linux kernel.
+
+
+== See also ==
+Memory ballooning
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Message_Understanding_Conference-0.md b/data/en.wikipedia.org/wiki/Message_Understanding_Conference-0.md
new file mode 100644
index 000000000..6c5ed2ce1
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Message_Understanding_Conference-0.md
@@ -0,0 +1,39 @@
+---
+title: "Message Understanding Conference"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Message_Understanding_Conference"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:15.968383+00:00"
+instance: "kb-cron"
+---
+
+The Message Understanding Conferences (MUC) for computing and computer science were initiated and financed by DARPA (Defense Advanced Research Projects Agency) to encourage the development of new and better methods of information extraction. The character of this competition, many concurrent research teams competing against one another—required the development of standards for evaluation, e.g. the adoption of metrics like precision and recall.
+
+
+== Topics and exercises ==
+Only for the first conference (MUC-1) could the participant choose the output format for the extracted
+information. From the second conference the output format, by which the participants'
+systems would be evaluated, was prescribed. For each topic fields were given, which had to be
+filled with information
+from the text. Typical fields were, for example, the cause, the agent, the time and place of an event,
+the consequences etc. The number of fields increased from conference to conference.
+At the sixth conference (MUC-6) the task of  recognition of  named entities and coreference was added.
+For named entity all phrases in the text were supposed to be marked as person, location, organization,
+time or quantity.
+The topics and text sources, which were processed, show a continuous move from military to civil themes, which mirrored
+the change in business interest in information extraction taking place at the time.
+
+
+== Literature ==
+Ralph Grishman, Beth Sundheim: Message Understanding Conference - 6: A Brief History. In: Proceedings of the 16th International Conference on Computational Linguistics (COLING), I, Copenhagen, 1996, 466–471.
+
+
+== See also ==
+DARPA TIPSTER Program
+
+
+== External links ==
+MUC-7
+MUC-6
+SAIC Information Extraction
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Meta-tracing-0.md b/data/en.wikipedia.org/wiki/Meta-tracing-0.md
new file mode 100644
index 000000000..25367400d
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Meta-tracing-0.md
@@ -0,0 +1,23 @@
+---
+title: "Meta-tracing"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Meta-tracing"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:17.175488+00:00"
+instance: "kb-cron"
+---
+
+Meta-tracing is a mostly automatic transformation that takes an interpreter as input and produces a tracing just-in-time compiler as output. Since interpreters are usually easier to write than compilers, but run slower, this technique can make it easier to produce efficient implementations of programming languages.
+The essence of the approach is based on the use of two levels of interpretation, in which a tracing interpreter is used to execute a second interpreter that interprets the target language for which a compiler is to be generated; the tracing interpreter then watches the second interpreter as it executes sequences of instructions generated from the input program.  
+This approach is used by the PyPy project to create their Python compiler, by meta-tracing a Python interpreter written in RPython, a restricted version of the Python programming language. In the special case of RPython, the RPython language is itself interpreted by an interpreter written in the full Python language, symbolized by the PyPy project's logo of an ouroboros.
+RPython has also been used to create an interpreter for the Scheme programming language.
+Meta-tracing can be compared to the AST-guided partial evaluation approach for generating compilers, such as the Truffle/JS compiler for the JavaScript programming language. Both meta-tracing and AST-guided partial evaluation can be viewed as examples of Futamura projection.
+
+
+== References ==
+
+
+== See also ==
+Copy-and-patch, another way to rapidly create compilers
+Compiler-compiler
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Microparallelism-0.md b/data/en.wikipedia.org/wiki/Microparallelism-0.md
new file mode 100644
index 000000000..b4a853b3b
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Microparallelism-0.md
@@ -0,0 +1,14 @@
+---
+title: "Microparallelism"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Microparallelism"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:18.381917+00:00"
+instance: "kb-cron"
+---
+
+Microparallelism is the use of software to exploit fine-grained parallelism within standard computer processors, by writing code that allows the full use of existing parallel units within superscalar processors.
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/MindModeling@Home-0.md b/data/en.wikipedia.org/wiki/MindModeling@Home-0.md
index 4f5765838..886c5823c 100644
--- a/data/en.wikipedia.org/wiki/MindModeling@Home-0.md
+++ b/data/en.wikipedia.org/wiki/MindModeling@Home-0.md
@@ -4,7 +4,7 @@ chunk: 1/1
 source: "https://en.wikipedia.org/wiki/MindModeling@Home"
 category: "reference"
 tags: "science, encyclopedia"
-date_saved: "2026-05-05T10:12:22.618731+00:00"
+date_saved: "2026-05-05T11:36:19.677174+00:00"
 instance: "kb-cron"
 ---
 
diff --git a/data/en.wikipedia.org/wiki/Minger_Email_Address_Verification_Protocol-0.md b/data/en.wikipedia.org/wiki/Minger_Email_Address_Verification_Protocol-0.md
new file mode 100644
index 000000000..f37fb0070
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Minger_Email_Address_Verification_Protocol-0.md
@@ -0,0 +1,16 @@
+---
+title: "Minger Email Address Verification Protocol"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Minger_Email_Address_Verification_Protocol"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:20.858017+00:00"
+instance: "kb-cron"
+---
+
+Minger Email Address Verification Protocol is an Internet Engineering Task Force draft for lightweight verification of an e-mail address between trusted servers. It was created by Arvel Hathcock and Jonathan Merkel as a practical alternative to the Finger protocol or SMTP call-forward. The MDaemon e-mail server uses Minger to realize domain sharing over multiple servers with distributed mailboxes.
+IANA has reserved and assigned TCP and UDP port 4069 to Minger protocol.
+On February 3, 2010, draft 6 expired. On March 9, 2016, draft 7 was released, but it is available only within MDaemon's documentation.
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Mink_Beauty-0.md b/data/en.wikipedia.org/wiki/Mink_Beauty-0.md
new file mode 100644
index 000000000..351286ee7
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Mink_Beauty-0.md
@@ -0,0 +1,20 @@
+---
+title: "Mink Beauty"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Mink_Beauty"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:22.054866+00:00"
+instance: "kb-cron"
+---
+
+Mink Beauty, LLC, is a 3D printing company based in New York. The company created a 3D printer allows users to select any color and print it into an eye shadow pod.
+Mink was founded by Harvard grad Grace Choi and debuted at TechCrunch's Disrupt conference in May 2014. The printer combines ink with a variety of substrates to "create any type of makeup, from powders to cream to lipstick," according to Choi. All ink used by Mink is FDA-approved.
+The printer was initially estimated to retail at $300.
+
+
+== References ==
+
+
+== External links ==
+Mink Printer User Manual — how it works, from official Mink website. Archived 2016-03-27 at the Wayback Machine
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Mirror_(programming)-0.md b/data/en.wikipedia.org/wiki/Mirror_(programming)-0.md
new file mode 100644
index 000000000..046dcc9bb
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Mirror_(programming)-0.md
@@ -0,0 +1,32 @@
+---
+title: "Mirror (programming)"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Mirror_(programming)"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:23.320817+00:00"
+instance: "kb-cron"
+---
+
+In computer programming, a mirror is a reflection mechanism that is completely decoupled from the object whose structure is being introspected. This is as opposed to traditional reflection, for example in Java, where one introspects an object using methods from the object itself (e.g. getClass()).
+Mirrors adhere to the qualities of encapsulation, stratification and ontological correspondence.
+
+
+== Benefits ==
+Decoupling the reflection mechanism from the objects themselves allows for a few benefits:
+
+The object's interface is not polluted, so there is no danger of breaking reflection by overriding a reflective method.
+There can be different mirror systems.
+The mirror system can be removed entirely (potentially allowing for optimizations).
+A mirror system can operate on remote code, since it is not coupled with a particular machine.
+
+
+== Languages that use mirrors ==
+Dart, via its reflect function.
+Inko, via its std::mirror module.
+Rubinius (Ruby implementation), via its Rubinius::Mirror.reflect method.
+Scala
+Swift, via its reflect function.
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Modularity-driven_testing-0.md b/data/en.wikipedia.org/wiki/Modularity-driven_testing-0.md
new file mode 100644
index 000000000..961cf0edf
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Modularity-driven_testing-0.md
@@ -0,0 +1,18 @@
+---
+title: "Modularity-driven testing"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Modularity-driven_testing"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:25.770571+00:00"
+instance: "kb-cron"
+---
+
+Modularity-driven testing is a term used in the testing of software. The test script modularity framework requires the creation of small, independent scripts that represent modules, sections, and functions of the application-under-test. These small scripts are then used in a hierarchical fashion to construct larger tests, realizing a particular test case.
+
+
+== Background ==
+Of all the frameworks, this one should be the simplest to grasp and master. It is a well-known programming strategy to build an abstraction layer in front of a component to hide the component from the rest of the application. This insulates the application from modifications in the component and provides modularity in the application design. The test script modularity framework applies this principle of abstraction or encapsulation in order to improve the maintainability and scalability of automated test suites.
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Molecular_computational_identification-0.md b/data/en.wikipedia.org/wiki/Molecular_computational_identification-0.md
new file mode 100644
index 000000000..d0408364e
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Molecular_computational_identification-0.md
@@ -0,0 +1,18 @@
+---
+title: "Molecular computational identification"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Molecular_computational_identification"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:26.928964+00:00"
+instance: "kb-cron"
+---
+
+Molecular computational identification (MCID) is a technique in which molecules are used as means for identifying individual cells or nanodevices.
+
+
+== See also ==
+RFID
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Moodbar-0.md b/data/en.wikipedia.org/wiki/Moodbar-0.md
new file mode 100644
index 000000000..131395e3f
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Moodbar-0.md
@@ -0,0 +1,26 @@
+---
+title: "Moodbar"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Moodbar"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:28.105645+00:00"
+instance: "kb-cron"
+---
+
+Moodbar is a computer visualization used for navigating within a piece of music or any other recording on a digital audio track. This is done with a commonly horizontal bar that is divided into vertical stripes. Each stripe has a colour combination showing the "mood" within a short part of the audio track. The colour can depend on spectrum and/or rhythmic features of the part of the track. If the audio is a song then various parts of it (intro, choruses, solos, accents etc.) as well as changes (dynamics, rhythm, texture, playing instruments) are differently coloured on the bar. If the audio is a speech or an interview then the moodbar displays different speaking segments in unique colour combinations. 
+Moodbar was originally presented by Gavin Wood and Simon O’Keefe in their paper On Techniques for Content-Based Visual Annotation to Aid Intra-Track Music Navigation. 
+Moodbar has been implemented for Amarok, Clementine, its fork, and Exaile music players and the GJay smart playlist creator for Linux.
+As of 2008, the default implementation of Amarok's moodbar only uses the spectral content of the current section of the track. It calculates the energy in the low, medium, and high frequency bands, and turns this into the amount of red, green, and blue in the corresponding stripe. Each moodbar file is 1000 samples long, which corresponds to roughly 4–5 samples every second for a typical 3–4 minute long song. This is not useful for telling anything about the rhythm of a song, but it is sometimes possible to guess where different instruments are playing. This can be useful for spotting verse, chorus, verse structure, and breaks in the music.
+
+
+== See also ==
+Music Genome Project
+Acoustic fingerprint
+
+
+== References ==
+
+
+== External links ==
+The Moodbar page in the Amarok User Manual
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Morphological_gradient-0.md b/data/en.wikipedia.org/wiki/Morphological_gradient-0.md
new file mode 100644
index 000000000..3186af43c
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Morphological_gradient-0.md
@@ -0,0 +1,234 @@
+---
+title: "Morphological gradient"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Morphological_gradient"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:29.332732+00:00"
+instance: "kb-cron"
+---
+
+In mathematical morphology and digital image processing, a morphological gradient is the difference between the dilation and the erosion of a given image. It is an image where each pixel value (typically non-negative) indicates the contrast intensity in the close neighborhood of that pixel. It is useful for edge detection and segmentation applications.
+
+
+== Mathematical definition and types ==
+Let 
+  
+    
+      
+        f
+        :
+        E
+        ↦
+        R
+      
+    
+    {\displaystyle f:E\mapsto R}
+  
+ be a grayscale image, mapping points from a Euclidean space or discrete grid E (such as R2 or Z2) into the real line. Let 
+  
+    
+      
+        b
+        (
+        x
+        )
+      
+    
+    {\displaystyle b(x)}
+  
+ be a grayscale structuring element. Usually, b is symmetric and has short-support, e.g., 
+
+  
+    
+      
+        b
+        (
+        x
+        )
+        =
+        
+          {
+          
+            
+              
+                
+                  0
+                  ,
+                
+                
+                  
+                    |
+                  
+                  x
+                  
+                    |
+                  
+                  ≤
+                  1
+                  ,
+                
+              
+              
+                
+                  −
+                  ∞
+                  ,
+                
+                
+                  
+                    
+                      otherwise
+                    
+                  
+                
+              
+            
+          
+          
+        
+      
+    
+    {\displaystyle b(x)=\left\{{\begin{array}{ll}0,&|x|\leq 1,\\-\infty ,&{\mbox{otherwise}}\end{array}}\right.}
+  
+.
+Then, the morphological gradient of f is given by:
+
+  
+    
+      
+        G
+        (
+        f
+        )
+        =
+        f
+        ⊕
+        b
+        −
+        f
+        ⊖
+        b
+      
+    
+    {\displaystyle G(f)=f\oplus b-f\ominus b}
+  
+,
+where 
+  
+    
+      
+        ⊕
+      
+    
+    {\displaystyle \oplus }
+  
+ and 
+  
+    
+      
+        ⊖
+      
+    
+    {\displaystyle \ominus }
+  
+ denote the dilation and the erosion, respectively.
+An internal gradient is given by:
+
+  
+    
+      
+        
+          G
+          
+            i
+          
+        
+        (
+        f
+        )
+        =
+        f
+        −
+        f
+        ⊖
+        b
+      
+    
+    {\displaystyle G_{i}(f)=f-f\ominus b}
+  
+,
+and an external gradient is given by:
+
+  
+    
+      
+        
+          G
+          
+            e
+          
+        
+        (
+        f
+        )
+        =
+        f
+        ⊕
+        b
+        −
+        f
+      
+    
+    {\displaystyle G_{e}(f)=f\oplus b-f}
+  
+.
+The internal and external gradients are "thinner" than the gradient, but the gradient peaks are located on the edges, whereas the internal and external ones are located at each side of the edges. Notice that 
+  
+    
+      
+        
+          G
+          
+            i
+          
+        
+        +
+        
+          G
+          
+            e
+          
+        
+        =
+        G
+      
+    
+    {\displaystyle G_{i}+G_{e}=G}
+  
+.
+If 
+  
+    
+      
+        b
+        (
+        0
+        )
+        ≥
+        0
+      
+    
+    {\displaystyle b(0)\geq 0}
+  
+, then all the three gradients have non-negative values at all pixels.
+
+
+== References ==
+Image Analysis and Mathematical Morphology by Jean Serra, ISBN 0-12-637240-3 (1982)
+Image Analysis and Mathematical Morphology, Volume 2: Theoretical Advances by Jean Serra, ISBN 0-12-637241-1 (1988)
+An Introduction to Morphological Image Processing by Edward R. Dougherty, ISBN 0-8194-0845-X (1992)
+
+
+== External links ==
+Morphological gradients, Centre de Morphologie Mathématique, École_des_Mines_de_Paris
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Mortality_(computability_theory)-0.md b/data/en.wikipedia.org/wiki/Mortality_(computability_theory)-0.md
new file mode 100644
index 000000000..69b5fe0cd
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Mortality_(computability_theory)-0.md
@@ -0,0 +1,110 @@
+---
+title: "Mortality (computability theory)"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Mortality_(computability_theory)"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:30.559232+00:00"
+instance: "kb-cron"
+---
+
+In computability theory, the mortality problem is a decision problem related to the halting problem. For Turing machines, the halting problem can be stated as follows:
+Given a Turing machine, and an input, decide whether the machine halts when run on the given input.
+In contrast, the mortality problem for Turing machines asks whether all executions of the machine, starting from any configuration, halt. 
+In the statement above, a configuration specifies both the machine's state (not necessarily its initial state),
+its tape position and the contents of the tape. While we usually assume that in the starting configuration all but finitely many cells on the tape are blanks, in the mortality problem the tape can have arbitrary content, including infinitely many non-blank symbols written on it.
+Philip K. Hooper proved in 1966 that the mortality problem is undecidable. This is true both for a machine with a tape infinite in both directions, and for a machine with semi-infinite tape. Note that this result does not directly follow from the well-known total function problem (Does a given machine halt for every input?), since the latter problem concerns only valid computations (starting with an initial configuration).
+The variant in which only finite configurations are considered is also undecidable, as proved by Herman, who calls it ''the uniform halting problem''. He shows that the problem is not just undecidable, but 
+  
+    
+      
+        
+          Π
+          
+            2
+          
+          
+            0
+          
+        
+      
+    
+    {\displaystyle \Pi _{2}^{0}}
+  
+-complete.
+
+
+== Additional models ==
+The problem can naturally be rephrased for any computational model in which there are notions of "configuration" and "transition". A member of the model will be mortal if there is no configuration that leads to an infinite chain of transitions.  The mortality problem has been proved undecidable for:
+
+Semi-Thue systems and Markov algorithms.
+Counter machines
+Dynamical systems over 
+  
+    
+      
+        
+          
+            
+              R
+            
+          
+          
+            n
+          
+        
+      
+    
+    {\displaystyle {\mathbb {R} }^{n}}
+  
+ or 
+  
+    
+      
+        
+          
+            
+              Q
+            
+          
+          
+            n
+          
+        
+      
+    
+    {\displaystyle {\mathbb {Q} }^{n}}
+  
+ or 
+  
+    
+      
+        
+          
+            
+              Z
+            
+          
+          
+            n
+          
+        
+      
+    
+    {\displaystyle {\mathbb {Z} }^{n}}
+  
+, for 
+  
+    
+      
+        n
+        ≥
+        2
+      
+    
+    {\displaystyle n\geq 2}
+  
+, where the transition function is piecewise linear (here, an arbitrary point, e.g., the origin, is selected as a halting state).
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Multi-touch,_physics_and_gestures-0.md b/data/en.wikipedia.org/wiki/Multi-touch,_physics_and_gestures-0.md
new file mode 100644
index 000000000..b7b744985
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Multi-touch,_physics_and_gestures-0.md
@@ -0,0 +1,14 @@
+---
+title: "Multi-touch, physics and gestures"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Multi-touch,_physics_and_gestures"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:34.212753+00:00"
+instance: "kb-cron"
+---
+
+In human–computer interaction, MPG stands for "multi-touch, physics and gestures", referencing a common method of interacting with computers and various electronic devices. The most notable MPG device is the Apple Inc iPhone, which makes use of many multi-touch gestures to operate various functions of the phone and applications on the phone.
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Multilevel_queue-0.md b/data/en.wikipedia.org/wiki/Multilevel_queue-0.md
new file mode 100644
index 000000000..8bdefbd40
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Multilevel_queue-0.md
@@ -0,0 +1,24 @@
+---
+title: "Multilevel queue"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Multilevel_queue"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:35.394851+00:00"
+instance: "kb-cron"
+---
+
+Multi-level queueing, used at least since the late 1950s/early 1960s, is a queue with a predefined number of levels. Items get assigned to a particular level at insert (using some predefined algorithm), and thus cannot be moved to another level (unlike in the multilevel feedback queue). Items get removed from the queue by removing all items from a level, and then moving to the next. If an item is added to a level above, the "fetching" restarts from there. Each level of the queue is free to use its own scheduling, thus adding greater flexibility than merely having multiple levels in a queue.
+
+
+== Process Scheduling ==
+Multi-level queue  scheduling algorithm is used in scenarios where the processes can be classified into groups based on property like process type, CPU time, IO access, memory size, etc. One general classification of the processes is foreground processes and background processes. In a multi-level queue scheduling algorithm, there will be 'n' number of queues, where 'n' is the number of groups the processes are classified into. Each queue will be assigned a priority and will have its own scheduling algorithm like Round-robin scheduling or FCFS. For the process in a queue to execute, all the queues of priority higher than it should be empty, meaning the process in those high priority queues should have completed its execution. In this scheduling algorithm, once assigned to a queue, the process will not move to any other queues.
+Consider the following table with the arrival time, execute time and type of the process (foreground or background - where foreground processes are given high priority) to understand non pre-emptive and pre-emptive multilevel scheduling in depth with FCFS algorithm for both the queues:
+
+
+== See also ==
+Fair-share scheduling
+Lottery scheduling
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/N-jet-0.md b/data/en.wikipedia.org/wiki/N-jet-0.md
new file mode 100644
index 000000000..3b5f26b48
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/N-jet-0.md
@@ -0,0 +1,64 @@
+---
+title: "N-jet"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/N-jet"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:36.619229+00:00"
+instance: "kb-cron"
+---
+
+An N-jet is the set of (partial) derivatives of a function 
+  
+    
+      
+        f
+        (
+        x
+        )
+      
+    
+    {\displaystyle f(x)}
+  
+ up to order N.
+Specifically, in the area of computer vision, the N-jet is usually computed from a scale space representation 
+  
+    
+      
+        L
+      
+    
+    {\displaystyle L}
+  
+ of the input image 
+  
+    
+      
+        f
+        (
+        x
+        ,
+        y
+        )
+      
+    
+    {\displaystyle f(x,y)}
+  
+, and the partial derivatives of 
+  
+    
+      
+        L
+      
+    
+    {\displaystyle L}
+  
+ are used as a basis for expressing various types of visual modules. For example, algorithms for tasks such as feature detection, feature classification, stereo matching, tracking and object recognition can be expressed in terms of N-jets computed at one or several scales in scale space.
+
+
+== See also ==
+Scale space implementation
+Jet (mathematics)
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Naimi–Trehel_algorithm-0.md b/data/en.wikipedia.org/wiki/Naimi–Trehel_algorithm-0.md
new file mode 100644
index 000000000..805f95ffb
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Naimi–Trehel_algorithm-0.md
@@ -0,0 +1,18 @@
+---
+title: "Naimi–Trehel algorithm"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Naimi–Trehel_algorithm"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:37.803477+00:00"
+instance: "kb-cron"
+---
+
+The Naimi–Trehel algorithm is an algorithm for achieving mutual exclusion in a distributed system.
+Unlike Lamport's distributed mutual exclusion algorithm and its related version, this algorithm does not use logical clocks.
+This method requires only O(log(number of processes in the network)) messages on average.
+When a process invokes a critical section, it sends a request to a queue at a particular processor which is specified by a path built by the algorithm as it runs.
+
+
+== References ==
+article at citeseerx.ist.psu.edu by Mohamed Naimi, Michel Trehel, André Arnold
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Nano-threads-0.md b/data/en.wikipedia.org/wiki/Nano-threads-0.md
new file mode 100644
index 000000000..57f05384f
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Nano-threads-0.md
@@ -0,0 +1,14 @@
+---
+title: "Nano-threads"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Nano-threads"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:39.044796+00:00"
+instance: "kb-cron"
+---
+
+In computer science nano-threads are highly optimized lightweight threads designed for use on shared memory multiprocessors (such as SMPs). The Nano-threads specification was written in 1997.
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Negative_cache-0.md b/data/en.wikipedia.org/wiki/Negative_cache-0.md
new file mode 100644
index 000000000..b09626013
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Negative_cache-0.md
@@ -0,0 +1,29 @@
+---
+title: "Negative cache"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Negative_cache"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:40.230412+00:00"
+instance: "kb-cron"
+---
+
+In computer programming, negative cache is a cache that also stores "negative" responses, i.e. failures. This means that a program remembers the result indicating a failure even after the cause has been corrected. Usually negative cache is a design choice, but it can also be a software bug.
+
+
+== Examples ==
+Consider a web browser which attempts to load a page while the network is unavailable. The browser will receive an error code indicating the problem, and may display this error message to the user in place of the requested page. However, it is incorrect for the browser to place the error message in the page cache, as this would lead it to display the error again when the user tries to load the same page - even after the network is back up. The error message must not be cached under the page's URL; until the browser is able to successfully load the page, whenever the user tries to load the page, the browser must make a new attempt.
+A frustrating aspect of negative caches is that the user may put a great effort into troubleshooting the problem, and then after determining and removing the root cause, the error still does not vanish.
+There are cases where failure-like states must be cached. For instance, DNS requires that caching nameservers remember negative responses as well as positive ones. If an authoritative nameserver returns a negative response, indicating that a name does not exist, this is cached. The negative response may be perceived as a failure at the application level; however, to the nameserver caching it, it is not a failure. The cache times for negative and positive caching may be tuned independently.
+
+
+== Description ==
+A negative cache is normally only desired if failure is very expensive and the error condition raises automatically without user's action. It creates a situation where the user is unable to isolate the cause of the failure: despite fixing everything they can think of, the program still refuses to work. When a failure is cached, the program should provide a clear indication of what must be done to clear the cache, in addition to a description of the cause of the error. In such conditions, a negative cache is an example of a design anti-pattern.
+Negative cache still may recover if the cached records expires.
+
+
+== See also ==
+Perl Design Patterns Book
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Nested_loop_join-0.md b/data/en.wikipedia.org/wiki/Nested_loop_join-0.md
new file mode 100644
index 000000000..b57fd3c97
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Nested_loop_join-0.md
@@ -0,0 +1,190 @@
+---
+title: "Nested loop join"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Nested_loop_join"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:41.498435+00:00"
+instance: "kb-cron"
+---
+
+A nested loop join is a naive algorithm that joins two relations by using two nested loops. Join operations are important for database management.
+
+
+== Algorithm ==
+Two relations 
+  
+    
+      
+        R
+      
+    
+    {\displaystyle R}
+  
+ and 
+  
+    
+      
+        S
+      
+    
+    {\displaystyle S}
+  
+ are joined as follows:
+
+algorithm nested_loop_join is
+    for each tuple r in R do
+        for each tuple s in S do
+            if r and s satisfy the join condition then
+                yield tuple <r,s>
+
+This algorithm will involve  nr*bs+ br block transfers and nr+br seeks, where br and bs are number of blocks in relations R and S respectively, and nr is the number of tuples in relation R.
+The algorithm runs in 
+  
+    
+      
+        O
+        (
+        
+          |
+        
+        R
+        
+          |
+        
+        
+          |
+        
+        S
+        
+          |
+        
+        )
+      
+    
+    {\displaystyle O(|R||S|)}
+  
+ I/Os, where 
+  
+    
+      
+        
+          |
+        
+        R
+        
+          |
+        
+      
+    
+    {\displaystyle |R|}
+  
+ and 
+  
+    
+      
+        
+          |
+        
+        S
+        
+          |
+        
+      
+    
+    {\displaystyle |S|}
+  
+ is the number of tuples contained in 
+  
+    
+      
+        R
+      
+    
+    {\displaystyle R}
+  
+ and 
+  
+    
+      
+        S
+      
+    
+    {\displaystyle S}
+  
+ respectively and can easily be generalized to join any number of relations ...
+The block nested loop join algorithm is a generalization of the simple nested loops algorithm that takes advantage of additional memory to reduce the number of times that the 
+  
+    
+      
+        S
+      
+    
+    {\displaystyle S}
+  
+ relation is scanned. It loads large chunks of relation R into main memory. For each chunk, it scans S and evaluates the join condition on all tuple pairs, currently in memory. This reduces the number of times S is scanned to once per chunk.
+
+
+== Index join variation ==
+If the inner relation has an index on the attributes used in the join, then the naive nest loop join can be replaced with an index join.
+
+algorithm index_join is
+    for each tuple r in R do
+        for each tuple s in S in the index lookup do
+            yield tuple <r,s>
+
+The time complexity for this variation improves from 
+  
+    
+      
+        O
+        (
+        
+          |
+        
+        R
+        
+          |
+        
+        
+          |
+        
+        S
+        
+          |
+        
+        )
+        
+           to 
+        
+        O
+        (
+        
+          |
+        
+        R
+        
+          |
+        
+        log
+        ⁡
+        
+          |
+        
+        S
+        
+          |
+        
+        )
+      
+    
+    {\displaystyle O(|R||S|){\text{ to }}O(|R|\log |S|)}
+  
+
+
+== See also ==
+Hash join
+Sort-merge join
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Northbound_interface-0.md b/data/en.wikipedia.org/wiki/Northbound_interface-0.md
new file mode 100644
index 000000000..0bc7817a6
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Northbound_interface-0.md
@@ -0,0 +1,26 @@
+---
+title: "Northbound interface"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Northbound_interface"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:42.656114+00:00"
+instance: "kb-cron"
+---
+
+In computer networking and computer architecture, a northbound interface of a component is an interface that allows the component to communicate with a higher level component, using the latter component's southbound interface. 
+The northbound interface conceptualizes the lower level details (e.g., data or functions) used by, or in, the component, allowing the component to interface with higher level layers.
+In architectural overviews, the northbound interface is normally drawn at the top of the component it is defined in; hence the name northbound interface.  
+A southbound interface decomposes concepts in the technical details, mostly specific to a single component of the architecture.  
+Southbound interfaces are drawn at the bottom of an architectural overview.
+
+
+== Typical use ==
+A northbound interface is typically an output-only interface (as opposed to one that accepts user input) found in carrier-grade network and telecommunications network elements. 
+The languages or protocols commonly used include SNMP and TL1. 
+For example, a device that is capable of sending out syslog messages but that is not configurable by the user is said to implement a northbound interface. 
+Other examples include SMASH, IPMI, WSMAN, and SOAP.
+The term is also important for software-defined networking (SDN), to facilitate communication between the physical devices, the SDN software and applications running on the network.
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/NovoGen-0.md b/data/en.wikipedia.org/wiki/NovoGen-0.md
new file mode 100644
index 000000000..99b07ec0d
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/NovoGen-0.md
@@ -0,0 +1,14 @@
+---
+title: "NovoGen"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/NovoGen"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:43.846317+00:00"
+instance: "kb-cron"
+---
+
+NovoGen is a proprietary form of 3D printing technology that allows scientists to assemble living tissue cells into a desired pattern. When combined with an extracellular matrix, the cells can be arranged into complex structures, such as organs. Designed by Organovo, the NovoGen technology has been successfully integrated by Invetech with a production printer that is intended to help develop processes for tissue repair and organ development.
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Nullary_constructor-0.md b/data/en.wikipedia.org/wiki/Nullary_constructor-0.md
new file mode 100644
index 000000000..229b5e008
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Nullary_constructor-0.md
@@ -0,0 +1,35 @@
+---
+title: "Nullary constructor"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Nullary_constructor"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:45.009411+00:00"
+instance: "kb-cron"
+---
+
+In computer programming, a nullary constructor is a constructor that takes no arguments. Also known as a 0-argument constructor, no-argument constructor, parameterless constructor or default constructor.
+
+
+== Object-oriented constructors ==
+In object-oriented programming, a constructor is code that is run when an object is created. Default constructors of objects are usually nullary.
+
+
+=== Java example ===
+
+
+=== C++ example ===
+
+
+== Algebraic data types ==
+In algebraic data types, a constructor is one of many tags that wrap data. If a constructor does not take any data arguments, it is nullary.
+
+
+=== Haskell example ===
+
+
+== See also ==
+Default constructor
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Oaklisp-0.md b/data/en.wikipedia.org/wiki/Oaklisp-0.md
new file mode 100644
index 000000000..b1b2a1a52
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Oaklisp-0.md
@@ -0,0 +1,23 @@
+---
+title: "Oaklisp"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Oaklisp"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:46.208579+00:00"
+instance: "kb-cron"
+---
+
+Oaklisp is a message based portable object-oriented Scheme developed by Kevin J. Lang and Barak A. Pearlmutter while Computer Science PhD students at Carnegie Mellon University.  Oaklisp uses a superset of Scheme syntax.  It is based on generic operations rather than functions, and features anonymous classes, multiple inheritance, a strong error system, setters and locators for operations, and a facility for dynamic binding.
+Version 1.2 includes an interface, bytecode compiler, run-time system and documentation.
+
+
+== References ==
+
+Kevin J. Lang and Barak A. Pearlmutter (November 1986). "Oaklisp: An object-oriented Scheme with first-class types" (PDF). ACM SIGPLAN Notices. 21 (11): 30–7. doi:10.1145/960112.28701.
+Kevin J. Lang and Barak A. Pearlmutter (May 1988). "Oaklisp: an object-oriented dialect of Scheme". LISP and Symbolic Computation. 1 (1): 39–51. CiteSeerX 10.1.1.13.8118. doi:10.1007/BF01806175.
+Barak A. Pearlmutter and Kevin J. Lang (1991). "The Implementation of Oaklisp". In Peter Lee (ed.). Topics in Advanced Language Implementation. Cambridge MA: MIT Press. pp. 189–215. ISBN 978-0-262-12151-4.
+
+
+== External links ==
+Oaklisp homepage
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Object_hierarchy-0.md b/data/en.wikipedia.org/wiki/Object_hierarchy-0.md
new file mode 100644
index 000000000..1b3fd04f2
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Object_hierarchy-0.md
@@ -0,0 +1,14 @@
+---
+title: "Object hierarchy"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Object_hierarchy"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:47.410228+00:00"
+instance: "kb-cron"
+---
+
+An object hierarchy is a concept from computer programming. It references descendants of objects acting as properties of an object. An example of this would be the object controlling a window (at the top of the hierarchy) having another object like the window's border acting as a property of the window.
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Observational_equivalence-0.md b/data/en.wikipedia.org/wiki/Observational_equivalence-0.md
new file mode 100644
index 000000000..bd90fac78
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Observational_equivalence-0.md
@@ -0,0 +1,21 @@
+---
+title: "Observational equivalence"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Observational_equivalence"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:48.617606+00:00"
+instance: "kb-cron"
+---
+
+Observational equivalence is the property of two or more underlying entities being indistinguishable on the basis of their observable implications. Thus, for example, two scientific theories are observationally equivalent if all of their empirically testable predictions are identical, in which case empirical evidence cannot be used to distinguish which is closer to being correct; indeed, it may be that they are actually two different perspectives on one underlying theory.
+In econometrics, two parameter values (or two structures, from among a class of statistical models) are considered observationally equivalent if they both result in the same probability distribution of observable data.  This term often arises in relation to the identification problem.
+In macroeconomics, it happens when you have multiple structural models, with different interpretation, but indistinguishable empirically. "the mapping between structural parameters and the objective function may not display a unique minimum."
+In the formal semantics of programming languages, two terms M and N are observationally equivalent if and only if, in all contexts C[...] where C[M] is a valid term, it is the case that C[N] is also a valid term with the same value. Thus it is not possible, within the system, to distinguish between the two terms. This definition can be made precise only with respect to a particular calculus, one that comes with its own specific definitions of term, context, and the value of a term. The notion is due to James H. Morris, who called it "extensional equivalence."
+
+
+== See also ==
+Underdetermination
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Occam-π-0.md b/data/en.wikipedia.org/wiki/Occam-π-0.md
new file mode 100644
index 000000000..8e3b66e36
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Occam-π-0.md
@@ -0,0 +1,36 @@
+---
+title: "Occam-π"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Occam-π"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:49.843827+00:00"
+instance: "kb-cron"
+---
+
+In computer science, occam-π (or occam-pi) is the name of a variant of the programming language occam developed by the Kent Retargetable occam Compiler (KRoC) team at the University of Kent. The name reflects the introduction of elements of π-calculus (pi-calculus) into occam, especially concepts involving mobile agents (processes) and data. The language contains several extensions to occam 2.1, including:
+
+Nested protocols
+Run-time process creation
+Mobile channels, data, and processes
+Recursion
+Protocol inheritance
+Array constructors
+Extended rendezvous
+
+
+== See also ==
+occam (programming language)
+Transputer
+KRoC
+Transterpreter
+
+
+== References ==
+
+
+== External links ==
+Official website
+University of Kent Occam-pi project page
+Tock Occam compiler
+Parallel programming users group on Occam-pi
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Offset_(computer_science)-0.md b/data/en.wikipedia.org/wiki/Offset_(computer_science)-0.md
new file mode 100644
index 000000000..449b9faca
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Offset_(computer_science)-0.md
@@ -0,0 +1,26 @@
+---
+title: "Offset (computer science)"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Offset_(computer_science)"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:51.042654+00:00"
+instance: "kb-cron"
+---
+
+In computer science, an offset within an array or other data structure object is an integer indicating the distance (displacement) between the beginning of the object and a given element or point, presumably within the same object. The concept of a distance is valid only if all elements of the object are of the same size (typically given in bytes or words).
+For example, if A is an array of characters containing "abcdef", the fourth element containing the character 'd' has an offset of three from the start of A.
+
+
+== In assembly language ==
+In computer engineering and low-level programming (such as assembly language), an offset usually denotes the number of address locations added to a base address in order to get to a specific absolute address. In this (original) meaning of offset, only the basic address unit, usually the 8-bit byte, is used to specify the offset's size. In this context an offset is sometimes called a relative address.
+In IBM System/360 instructions, a 12-bit offset embedded within certain instructions provided a range of between 0 and 4096 bytes. For example, within an unconditional branch instruction (X'47F0Fxxx'), the xxx 12-bit hexadecimal offset provided the byte offset from the base register (15) to branch to. An odd offset would cause a program check (unless the base register itself also contained an odd address)—since instructions had to be aligned on half-word boundaries to execute without a program or hardware interrupt.
+The previous example describes an indirect way to address to a memory location in the format of segment:offset. For example, assume we want to refer to memory location 0xF867.  One way this can be accomplished is by first defining a segment with beginning address 0xF000, and then defining an offset of 0x0867.  Further, we are also allowed to shift the hexadecimal segment to reach the final absolute memory address. One thing to note here is that we can reach our final absolute address in many ways.
+An offset is not always relative to the base address of the module, for example: If you have a class and you want to retrieve the "color" attribute of this class, the offset may be 0x0100, but this offset has to be added to the offset of the class itself, not the base address. If the class' offset is 0xFF881 and the base address is 0x0A100, then to retrieve the "color" attribute both offsets are added to the base address. 0x0A100 (base) + 0xFF881 (class) + 0x0100 (attribute). Ultimately the attribute's address will be 0x109A81.
+
+
+== See also ==
+Array Index
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/One-pass_algorithm-0.md b/data/en.wikipedia.org/wiki/One-pass_algorithm-0.md
new file mode 100644
index 000000000..2be043921
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/One-pass_algorithm-0.md
@@ -0,0 +1,44 @@
+---
+title: "One-pass algorithm"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/One-pass_algorithm"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:52.235906+00:00"
+instance: "kb-cron"
+---
+
+In computing, a one-pass algorithm or single-pass algorithm is a streaming algorithm which reads its input exactly once. It does so by processing items in order, without unbounded buffering; it reads a block into an input buffer, processes it, and moves the result into an output buffer for each step in the process. A one-pass algorithm generally requires O(n) (see 'big O' notation) time and less than O(n) storage (typically O(1)), where n is the size of the input. An example of a one-pass algorithm is the Sondik partially observable Markov decision process.
+
+
+== Example problems solvable by one-pass algorithms ==
+Given any list as an input:
+
+Count the number of elements.
+Given a list of numbers:
+
+Find the k largest or smallest elements, k given in advance.
+Find the sum, mean, variance and standard deviation of the elements of the list. See also Algorithms for calculating variance.
+Given a list of symbols from an alphabet of k symbols, given in advance.
+
+Count the number of times each symbol appears in the input.
+Find the most or least frequent elements.
+Sort the list according to some order on the symbols (possible since the and after number of symbols is limited).
+Find the maximum gap between two appearances of a given symbol.
+
+
+== Example problems not solvable by one-pass algorithms ==
+Given any list as an input:
+
+Find the nth element from the end (or report that the list has fewer than n elements).
+Find the middle element of the list.  However, this is solvable with two passes: Pass 1 counts the elements and pass 2 picks out the middle one.
+Given a list of numbers:
+
+Find the median.
+Find the modes (This is not the same as finding the most frequent symbol from a limited alphabet).
+Sort the list.
+Count the number of items greater than or less than the mean.  However, this can be done in constant memory with two passes: Pass 1 finds the average and pass 2 does the counting.
+The two-pass algorithms above are still streaming algorithms but not one-pass algorithms.
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Online_optimization-0.md b/data/en.wikipedia.org/wiki/Online_optimization-0.md
new file mode 100644
index 000000000..7fbfdbc6e
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Online_optimization-0.md
@@ -0,0 +1,36 @@
+---
+title: "Online optimization"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Online_optimization"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:53.498022+00:00"
+instance: "kb-cron"
+---
+
+Online optimization is a field of optimization theory, more popular in computer science and operations research, that deals with optimization problems having no or incomplete knowledge of the future (online). These kind of problems are denoted as online problems and are seen as opposed to the classical optimization problems where complete information is assumed (offline). The research on online optimization can be distinguished into online problems where multiple decisions are made sequentially based on a piece-by-piece input and those where a decision is made only once. A famous online problem where a decision is made only once is the Ski rental problem. In general, the output of an online algorithm is compared to the solution of a corresponding offline algorithm which is necessarily always optimal and knows the entire input in advance (competitive analysis).
+In many situations, present decisions (for example, resources allocation) must be made with incomplete knowledge of the future or distributional assumptions on the future are not reliable. In such cases, online optimization  can be used, which is different from other approaches such as robust optimization, stochastic optimization and Markov decision processes.
+
+
+== Online problems ==
+A problem exemplifying the concepts of online algorithms is the Canadian traveller problem. The goal of this problem is to minimize the cost of reaching a target in a weighted graph where some of the edges are unreliable and may have been removed from the graph. However, that an edge has been removed (failed) is only revealed to the traveller when they reach one of the edge's endpoints. The worst case for this problem is simply that all of the unreliable edges fail and the problem reduces to the usual shortest path problem. An alternative analysis of the problem can be made with the help of competitive analysis. For this method of analysis, the offline algorithm knows in advance which edges will fail and the goal is to minimize the ratio between the online and offline algorithms' performance. This problem is PSPACE-complete.
+There are many formal problems that offer more than one online algorithm as solution:
+
+k-server problem
+Job shop scheduling problem
+List update problem
+Bandit problem
+Secretary problem
+Search games
+Ski rental problem
+Linear search problem
+Portfolio selection problem
+Online matching
+
+
+== See also ==
+Online algorithm
+Online mirror descent
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Ontology_Definition_MetaModel-0.md b/data/en.wikipedia.org/wiki/Ontology_Definition_MetaModel-0.md
new file mode 100644
index 000000000..98b994446
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Ontology_Definition_MetaModel-0.md
@@ -0,0 +1,28 @@
+---
+title: "Ontology Definition MetaModel"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Ontology_Definition_MetaModel"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:54.711917+00:00"
+instance: "kb-cron"
+---
+
+The Ontology Definition MetaModel (ODM) is an Object Management Group (OMG) specification to make the concepts of Model-Driven Architecture applicable to the engineering of ontologies. Hence, it links Common Logic (CL), the Web Ontology Language (OWL), and the Resource Description Framework (RDF).
+OWL and RDF were initially defined to provide an XML-based machine to machine interchange of metadata and semantics. ODM now integrates these into visual modeling, giving a standard well-defined process for modeling the ontology, as well as, allowing for interoperability with other modeling based on languages like UML, SysML and UPDM.
+
+
+== See also ==
+Web Ontology Language
+Unified Modeling Language
+
+
+== External links ==
+Ontology Definition Metamodel (ODM)  Version 1.0, Object Management Group, May 2009
+W3C OWL ontology
+
+
+== Resources ==
+Eclipse ODM
+Enterprise Architect ODM MDG Technology
+Formal Modelling, Knowledge Representation and Reasoning for Design and Development of User-centric Pervasive Software: A Meta-review Archived 2013-12-15 at the Wayback Machine, article in International Journal of Metadata, Semantics and Ontologies, Vol 6, No 2 (2011), 96-125, by Ahmet Soylu, Patrick De Causmaecker, Davy Preuveneers, Yolande Berbers, and Piet Desmet
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Ontology_Inference_Layer-0.md b/data/en.wikipedia.org/wiki/Ontology_Inference_Layer-0.md
new file mode 100644
index 000000000..62f074e1c
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Ontology_Inference_Layer-0.md
@@ -0,0 +1,22 @@
+---
+title: "Ontology Inference Layer"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Ontology_Inference_Layer"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:55.884282+00:00"
+instance: "kb-cron"
+---
+
+OIL (Ontology Inference Layer or Ontology Interchange Language) can be regarded as an ontology infrastructure for the Semantic Web.  OIL is based on concepts developed in Description Logic (DL) and frame-based systems and is compatible with RDFS.
+OIL was developed by Dieter Fensel, Frank van Harmelen (Vrije Universiteit, Amsterdam) and Ian Horrocks (University of Manchester) as part of the IST OntoKnowledge project.
+Much of the work in OIL was subsequently incorporated into DAML+OIL and the Web Ontology Language (OWL).
+
+
+== See also ==
+DARPA Agent Markup Language (DAML)
+DAML+OIL
+Ontology
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Opaque_binary_blob-0.md b/data/en.wikipedia.org/wiki/Opaque_binary_blob-0.md
new file mode 100644
index 000000000..d5156f829
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Opaque_binary_blob-0.md
@@ -0,0 +1,28 @@
+---
+title: "Opaque binary blob"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Opaque_binary_blob"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:57.101557+00:00"
+instance: "kb-cron"
+---
+
+Opaque binary blob (OBB) is a term used in network engineering and computer science to refer to a sizeable piece of data, which looks like binary garbage from outside, by entities which do not know what that blob denotes or carries, but make sense to entities which have access permission and access functions to them. It is also a pejorative term for compiled code without the source code made available (see: binary blob).
+
+
+== Use in networks ==
+At least one network protocol, Advanced Message Queuing Protocol, uses the terminology of OBB.
+
+
+== Use in the computer field ==
+Android operating systems, starting with version 2.3 code named Gingerbread, use OBBs to refer in one blob to multiple files, maybe even a file system or whole file system in one file. These OBBs are available through the Storage Manager interface in Android. This is done as a means of abstraction, so multiple applications running on the operating system can more easily access the OBB. For example, if there was a map database (map OBB), multiple applications running on Android 2.3 can access the same maps. This eliminates the need to maintain different map data for different applications with similar functions and features. Many HD games on the Android platform use their own OBB files, to allow storage of large files on the device's external SD card.
+Tuxedo middleware also uses OBBs to mention C and C++ arrays, or typed data buffers. This probably (input needed from experts) is the oldest reference to OBBs used in a computer system.
+When a vendor distributes software in an object binary form without any mention of its inner workings or code, it is called a 'proprietary OBB' or 'proprietary blob' or just binary blob. This practice is to protect the company's intellectual property, and probably keep a competitive edge (see: proprietary software). This also prevents hackers from improving the system or subverting it. As an example, Nvidia Tegra has such a 'proprietary OBB.'
+
+
+== See also ==
+Binary blob
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Open_Architecture_Computing_Environment-0.md b/data/en.wikipedia.org/wiki/Open_Architecture_Computing_Environment-0.md
new file mode 100644
index 000000000..916030156
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Open_Architecture_Computing_Environment-0.md
@@ -0,0 +1,20 @@
+---
+title: "Open Architecture Computing Environment"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Open_Architecture_Computing_Environment"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:58.332803+00:00"
+instance: "kb-cron"
+---
+
+Open Architecture Computing Environment (OACE) was a specification that aimed to provide a standards-based computing environment in order to decouple computing environment from software applications. 
+It was proposed for the United States Department of Defense in 2004.
+
+
+== See also ==
+Open architecture
+Mission Data Interface
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Open_Knowledge_Base_Connectivity-0.md b/data/en.wikipedia.org/wiki/Open_Knowledge_Base_Connectivity-0.md
new file mode 100644
index 000000000..696c59ffb
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Open_Knowledge_Base_Connectivity-0.md
@@ -0,0 +1,18 @@
+---
+title: "Open Knowledge Base Connectivity"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Open_Knowledge_Base_Connectivity"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:36:59.556390+00:00"
+instance: "kb-cron"
+---
+
+Open Knowledge Base Connectivity (OKBC)  is a protocol and an API for accessing knowledge in knowledge representation systems such as ontology repositories and object–relational databases. It is somewhat complementary to the Knowledge Interchange Format that serves as a general representation language for knowledge. It is developed by SRI International's Artificial Intelligence Center for DARPA's High Performance Knowledge Base program (HPKB).
+
+
+== References ==
+
+
+== External links ==
+Open Knowledge Base Connectivity Home Page
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Operability-0.md b/data/en.wikipedia.org/wiki/Operability-0.md
new file mode 100644
index 000000000..0aef975e0
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Operability-0.md
@@ -0,0 +1,23 @@
+---
+title: "Operability"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Operability"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:37:00.753461+00:00"
+instance: "kb-cron"
+---
+
+Operability is the ability to keep a piece of equipment, a system or a whole industrial installation in a safe and reliable functioning condition, according to pre-defined operational requirements.
+In a computing systems environment with multiple systems this includes the ability of products, systems and business processes to work together to accomplish a common task such as finding and returning availability of inventory for flight.
+For a gas turbine engine, operability addresses the installed aerodynamic operation of the engine to ensure that it operates with care-free throttle handling without compressor stall or surge or combustor flame-out. There must be no unacceptable loss of power or handling deterioration after ingesting birds, rain and hail or ingesting or accumulating ice. Design and development responsibilities include the components through which the thrust/power-producing flow passes, i.e. the intake, compressor, combustor, fuel system, turbine and exhaust. They also include the software in the computers which control the way the engine changes its speed in response to the actions of the pilot in selecting a start, selecting different idle settings and higher power ratings such as take-off, climb and cruise. The engine has to start to idle and accelerate and decelerate within agreed, or mandated, times while remaining within operating limits (shaft speeds, turbine temperature, combustor casing pressure) over the required aircraft operating envelope.
+Operability is considered one of the ilities and is closely related to reliability, supportability and maintainability.
+Operability also refers to whether or not a surgical operation can be performed to treat a patient with a reasonable degree of safety and chance of success.
+
+
+== References ==
+
+
+== External links ==
+Software Operability
+Examples Software Operability Requirements
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Ordinal_tree-0.md b/data/en.wikipedia.org/wiki/Ordinal_tree-0.md
new file mode 100644
index 000000000..386213ca9
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Ordinal_tree-0.md
@@ -0,0 +1,18 @@
+---
+title: "Ordinal tree"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Ordinal_tree"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:37:01.986630+00:00"
+instance: "kb-cron"
+---
+
+An ordinal tree, by analogy with an ordinal number, is a rooted tree of arbitrary degree in which the children of each node are ordered, so that one refers to the ith child in the sequence of children of a node.
+
+
+== See also ==
+Cardinal tree
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Orthogonality_(term_rewriting)-0.md b/data/en.wikipedia.org/wiki/Orthogonality_(term_rewriting)-0.md
new file mode 100644
index 000000000..f1604a6df
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Orthogonality_(term_rewriting)-0.md
@@ -0,0 +1,137 @@
+---
+title: "Orthogonality (term rewriting)"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Orthogonality_(term_rewriting)"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:37:03.225572+00:00"
+instance: "kb-cron"
+---
+
+Orthogonality as a property of term rewriting systems (TRSs) describes where the reduction rules of the system are all left-linear, that is each variable occurs only once on the left hand side of each reduction rule, and there is no overlap between them, i.e. the TRS has no critical pairs. For example 
+  
+    
+      
+        D
+        (
+        x
+        ,
+        x
+        )
+        →
+        E
+      
+    
+    {\displaystyle D(x,x)\to E}
+  
+ is not left-linear.
+Orthogonal TRSs have the consequent property that all reducible expressions (redexes) within a term are completely disjoint—that is, the redexes share no common function symbol.
+For example, the TRS with reduction rules
+
+  
+    
+      
+        
+          
+            
+              
+                
+                  ρ
+                  
+                    1
+                  
+                
+                :
+                 
+              
+              
+                f
+                (
+                x
+                ,
+                y
+                )
+              
+              
+                →
+              
+              
+                g
+                (
+                y
+                )
+              
+            
+            
+              
+                
+                  ρ
+                  
+                    2
+                  
+                
+                :
+                 
+              
+              
+                h
+                (
+                y
+                )
+              
+              
+                →
+              
+              
+                f
+                (
+                g
+                (
+                y
+                )
+                ,
+                y
+                )
+              
+            
+          
+        
+      
+    
+    {\displaystyle {\begin{array}{lrcl}\rho _{1}:\ &f(x,y)&\rightarrow &g(y)\\\rho _{2}:\ &h(y)&\rightarrow &f(g(y),y)\end{array}}}
+  
+
+is orthogonal—it is easy to observe that each reduction rule is left-linear, and the left hand side of each reduction rule shares no function symbol in common, so there is no overlap.
+Orthogonal TRSs are confluent.
+
+
+== Weak orthogonality ==
+A TRS is weakly orthogonal if it is left-linear and contains only trivial critical pairs, i.e. if 
+  
+    
+      
+        (
+        t
+        ,
+        s
+        )
+      
+    
+    {\displaystyle (t,s)}
+  
+ is a critical pair then 
+  
+    
+      
+        t
+        =
+        s
+      
+    
+    {\displaystyle t=s}
+  
+. Weakly orthogonal TRSs are confluent.
+A TRS is almost orthogonal if it is weakly orthogonal and has the additional property that overlap between redex occurrences occurs only at the root of the redex occurrences.
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/PSI_Comp_80-0.md b/data/en.wikipedia.org/wiki/PSI_Comp_80-0.md
new file mode 100644
index 000000000..a793d30bd
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/PSI_Comp_80-0.md
@@ -0,0 +1,31 @@
+---
+title: "PSI Comp 80"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/PSI_Comp_80"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:37:42.343408+00:00"
+instance: "kb-cron"
+---
+
+The PSI Comp 80 was a home computer sold by Powertran starting in 1979. It was sold in the form of a kit of parts for a cased single-board home computer system.
+The system was based on a Z80 microprocessor addressing a mixture of 8 KB of system RAM and EPROM, plus 2 KB of video RAM.
+It used a National Semiconductor MM57109N as a mathematical co-processor to speed up calculations.
+
+
+== History and specifications ==
+In 1979, the British magazine Wireless World published the technical details for a "Scientific Computer". Shortly afterward the British firm Powertran used this design for their implementation, which they called the PSI Comp 80.
+Ahead of its time, it incorporated a number crunching coprocessor and a novel language embedded in EPROM called Basic Using Reverse Polish - BURP.
+The monochrome Video Display Controller could simultaneously display combinations of 32 lines of 64 characters, and 128 x 64 resolution graphics by either displaying a normal character or a "pseudo graphics" character, with pixel blocks in a 2x2 matrix. A technique similar to the one used in the TRS-80 - It could later be expanded to a higher resolution, although never to colour.
+Add-ons were developed for the system, including memory expansions, floppy and hard disk interfaces, various software packages and a disk operating system, SCIDOS, which was CP/M-compatible but also included features - structured (pathed) disk folders, etc. - now very familiar to modern-day PC users.
+During the mid-1980s, the designer of this system, John Adams M.SC., published a new version of the Scientific Computer - the SC84 (Scientific Computer of 1984). It was based upon a backplane and plug-in cards and modules and featuring a Hitachi HD64180 processor, up to 512 kbytes of RAM and a high-resolution colour graphics system.
+
+
+== References ==
+PSI 2020
+
+
+== External links ==
+a picture of the advertisement for the PSI Comp 80 in Wireless World
+Links to Wireless World articles
+SC84 article
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Page_address_register-0.md b/data/en.wikipedia.org/wiki/Page_address_register-0.md
new file mode 100644
index 000000000..99b71cb79
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Page_address_register-0.md
@@ -0,0 +1,18 @@
+---
+title: "Page address register"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Page_address_register"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:37:04.416427+00:00"
+instance: "kb-cron"
+---
+
+A page address register (PAR) contains the physical addresses of pages currently held in the main memory of a computer system. PARs are used in order to avoid excessive use of an address table in some operating systems. A PAR may check a page's number against all entries in the PAR simultaneously, allowing it to retrieve the pages physical address quickly. A PAR is used by a single process and is only used for pages which are frequently referenced (though these pages may change as the process's behaviour changes in accordance with the principle of locality). An example computer which made use of PARs is the Atlas.
+
+
+== See also ==
+Translation Lookaside Buffer (TLB)
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Parallel_slowdown-0.md b/data/en.wikipedia.org/wiki/Parallel_slowdown-0.md
new file mode 100644
index 000000000..62058fc6f
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Parallel_slowdown-0.md
@@ -0,0 +1,20 @@
+---
+title: "Parallel slowdown"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Parallel_slowdown"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:37:05.545653+00:00"
+instance: "kb-cron"
+---
+
+Parallel slowdown is a phenomenon in parallel computing where parallelization of a parallel algorithm beyond a certain point causes the program to run slower (take more time to run to completion).
+Parallel slowdown is typically the result of a communications bottleneck. As more processor nodes are added, each processing node spends progressively more time doing communication than useful processing. At some point, the communications overhead created by adding another processing node surpasses the increased processing power that node provides, and parallel slowdown occurs. 
+Parallel slowdown occurs when the algorithm requires significant communication, particularly of intermediate results. Some problems, known as embarrassingly parallel problems, do not require such communication, and thus are not affected by slowdown.
+
+
+== See also ==
+Mythical man month, an analogous situation for a team programmers where productivity is affected by human communication.
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Parameter_validation-0.md b/data/en.wikipedia.org/wiki/Parameter_validation-0.md
new file mode 100644
index 000000000..43f2f72b8
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Parameter_validation-0.md
@@ -0,0 +1,26 @@
+---
+title: "Parameter validation"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Parameter_validation"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:37:06.725209+00:00"
+instance: "kb-cron"
+---
+
+In computer software, the term parameter validation is the automated processing, in a module, to validate the spelling or accuracy of parameters passed to that module.  The term has been in common use for over 30 years.  Specific best practices have been developed, for decades, to improve the handling of such parameters.
+Parameter validation can be used to defend against cross-site scripting attacks.
+
+
+== See also ==
+Data validation
+Strong typing
+Error handling
+Sanity check
+
+
+== Notes ==
+
+
+== References ==
+"Parameter validation for software reliability", G.B. Alleman, 1978, webpage: ACM-517: paper presents a method for increasing software reliability through parameter validation.
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Path_expression-0.md b/data/en.wikipedia.org/wiki/Path_expression-0.md
new file mode 100644
index 000000000..62ae445d5
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Path_expression-0.md
@@ -0,0 +1,29 @@
+---
+title: "Path expression"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Path_expression"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:37:07.940479+00:00"
+instance: "kb-cron"
+---
+
+In query languages, path expressions identify an object by describing how to navigate to it
+in some graph (possibly implicit) of objects. For example, the path expression p.Manager.Home.City might refer the city of residence of someone's manager.
+Path expressions have been extended to support regular expression-like flexibility.
+XPath is an example of a path expression language.
+In concurrency control, path expressions are a mechanism for expressing permitted sequences of execution. For example, a path expression like " {read},  write" might specify that either multiple simultaneous executions of read or a single execution of write but not both are allowed at any point in time.
+It is important to know that the path expressions are a mechanism for the synchronization of processes at the monitor level in the software. That provides a clear and structured approach to the description of shared data and the coordination and communication between concurrent processes. This method is flexible in its ability to express timing, and can be used in different ways.
+In addition, path expressions are useful for process synchronization for two reasons: first, the close relationship between stream expressions and regular expressions that simplify the task of writing and reasoning about programs that use this synchronization mechanism. Second, synchronization in many concurrent programs in a finite state, and therefore can be adequately described by regular expressions. For precisely the same reasons, path expressions are useful for controlling the behavior of complicated asynchronous circuits. In fact, the finite state assumption may be even more reasonable at the hardware level than at the monitor level.
+Path expressions provide a high level of descriptive synchronization that aids in the prevention and detection of design errors in complex systems and overcomes some of the dangers, such as certain forms of coding errors.
+
+
+== See also ==
+Object database
+
+
+== References ==
+M. Kifer; W. Kim & Y. Sagiv (1992). "Querying Object-Oriented Databases". Proc. of the ACM SIGMOD. pp. 393–402.
+Elisa Bertino, Mauro Negri, Giuseppe Pelagatti, and Licia Sbattella (June 1992). "Object-Oriented Query Languages: The Notion and the Issues". IEEE Transactions on Knowledge and Data Engineering. 4 (3): 223–236. doi:10.1109/69.142014.{{cite journal}}:  CS1 maint: multiple names: authors list (link)
+R. Campbell & R. Kolstad (1979). "Path Expressions in Pascal". Proceedings of the 4th International Conference on Software Engineering. Vol. 4. pp. 212–219.
+Tony Bloom (1979). "Evaluating Synchronization Mechanisms". Proceedings of the seventh ACM symposium on Operating systems principles. pp. 24–32.
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Peptide_computing-0.md b/data/en.wikipedia.org/wiki/Peptide_computing-0.md
new file mode 100644
index 000000000..c2e4073f7
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Peptide_computing-0.md
@@ -0,0 +1,28 @@
+---
+title: "Peptide computing"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Peptide_computing"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:37:09.166120+00:00"
+instance: "kb-cron"
+---
+
+Peptide computing is a form of computing which uses peptides, instead of traditional electronic components. The basis of this computational model is the affinity of antibodies towards peptide sequences. Similar to DNA computing, the parallel interactions of peptide sequences and antibodies have been used by this model to solve a few NP-complete problems.  Specifically, the hamiltonian path problem (HPP) and some versions of the set cover problem are a few NP-complete problems which have been solved using this computational model so far. This model of computation has also been shown to be computationally universal (or Turing complete).
+This model of computation has some critical advantages over DNA computing. For instance, while DNA is made of four building blocks, peptides are made of twenty building blocks. The peptide-antibody interactions are also more flexible with respect to recognition and affinity than an interaction between a DNA strand and its reverse complement. However, unlike DNA computing, this model is yet to be practically realized. The main limitation is the availability of specific monoclonal antibodies required by the model.
+
+
+== See also ==
+Biocomputers
+Computational gene
+Computational complexity theory
+DNA computing
+Molecular electronics
+Parallel computing
+Unconventional computing
+Molecular logic gate
+
+
+== References ==
+M. Sakthi Balan; Kamala Krithivasan; Y. Sivasubramanyam (2001). Peptide Computing - Universality and Complexity. Lecture Notes in Computer Science. Vol. 2340. pp. 290–299. doi:10.1007/3-540-48017-X_27. ISBN 978-3-540-43775-8.
+Hubert Hug & Rainer Schuler (2001). "Strategies for the development of a peptide computer". Bioinformatics. 17 (4): 364–368. doi:10.1093/bioinformatics/17.4.364. PMID 11301306.
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Persistent_programming_language-0.md b/data/en.wikipedia.org/wiki/Persistent_programming_language-0.md
new file mode 100644
index 000000000..e412c50af
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Persistent_programming_language-0.md
@@ -0,0 +1,43 @@
+---
+title: "Persistent programming language"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Persistent_programming_language"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:37:10.353239+00:00"
+instance: "kb-cron"
+---
+
+Programming languages that natively and seamlessly allow objects to continue existing after the program has been closed down are called persistent programming languages. JADE is one such language.
+A persistent programming language is a programming language extended with constructs to handle persistent data. It is distinguished from embedded SQL in at least two ways: 
+In a persistent programming language:
+
+The query language is fully integrated with the host language and both share the same type system.
+Any format changes required between the host language and the database are carried out transparently.
+In Embedded SQL:
+
+Where the host language and data manipulation language have different type systems, code conversion operates outside of the OO type system, and hence has a higher chance of having undetected errors.
+Format conversion must be handled explicitly and takes a substantial amount of code.
+Using Embedded SQL, a programmer is responsible for writing explicit code to fetch data into memory or store data back to the database. 
+In a persistent programming language, a programmer can manipulate persistent data without having to write such code explicitly. 
+The drawbacks of persistent programming languages include:
+
+While they are powerful, it is easy to make programming errors that damage the database.
+It is harder to do automatic high-level optimization.
+They do not support declarative querying well.
+
+
+== Examples ==
+MUMPS
+JADE
+Caché ObjectScript
+
+
+== See also ==
+Object-relational mapping
+Object-oriented database management systems
+Object prevalence
+Phantom OS - persistent OS project
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/PlanetLab-0.md b/data/en.wikipedia.org/wiki/PlanetLab-0.md
new file mode 100644
index 000000000..1e7c06572
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/PlanetLab-0.md
@@ -0,0 +1,21 @@
+---
+title: "PlanetLab"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/PlanetLab"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:37:11.525473+00:00"
+instance: "kb-cron"
+---
+
+PlanetLab was a group of computers available as a testbed for computer networking and distributed systems research. It was established in 2002 by Prof. Larry L. Peterson and Prof. David Culler, and by 2005 it had been deployed at 252 sites in 28 countries.  Each research project had a "slice", or virtual machine access to a subset of the nodes.
+Accounts were limited to persons affiliated with corporations and universities that hosted PlanetLab nodes. However, a number of free, public services have been deployed on PlanetLab, including CoDeeN, the Coral Content Distribution Network, and Open DHT. 
+PlanetLab was officially shut down in May 2020 but continues in Europe.
+
+
+== References ==
+
+
+== External links ==
+PlanetLab
+PlanetLab Europe
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/PlusCal-0.md b/data/en.wikipedia.org/wiki/PlusCal-0.md
new file mode 100644
index 000000000..29bfe6785
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/PlusCal-0.md
@@ -0,0 +1,24 @@
+---
+title: "PlusCal"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/PlusCal"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:37:12.703253+00:00"
+instance: "kb-cron"
+---
+
+PlusCal (formerly called +CAL) is a formal specification language created by Leslie Lamport, which transpiles to TLA+. In contrast to TLA+'s action-oriented focus on distributed systems, PlusCal most resembles an imperative programming language and is better-suited when specifying sequential algorithms. PlusCal was designed to replace pseudocode, retaining its simplicity while providing a formally defined and verifiable language. A one-bit clock is written in PlusCal as follows:
+
+
+== See also ==
+FizzBee
+TLA+
+Pseudocode
+
+
+== References ==
+
+
+== External links ==
+PlusCal tools and documentation are found on the PlusCal Algorithm Language page.
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Polar_surface_area-0.md b/data/en.wikipedia.org/wiki/Polar_surface_area-0.md
index 98a18e51e..17008ea5e 100644
--- a/data/en.wikipedia.org/wiki/Polar_surface_area-0.md
+++ b/data/en.wikipedia.org/wiki/Polar_surface_area-0.md
@@ -4,7 +4,7 @@ chunk: 1/1
 source: "https://en.wikipedia.org/wiki/Polar_surface_area"
 category: "reference"
 tags: "science, encyclopedia"
-date_saved: "2026-05-05T11:29:19.789707+00:00"
+date_saved: "2026-05-05T11:37:13.928960+00:00"
 instance: "kb-cron"
 ---
 
diff --git a/data/en.wikipedia.org/wiki/Polyvariance-0.md b/data/en.wikipedia.org/wiki/Polyvariance-0.md
new file mode 100644
index 000000000..3ab7193ed
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Polyvariance-0.md
@@ -0,0 +1,25 @@
+---
+title: "Polyvariance"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Polyvariance"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:37:24.381372+00:00"
+instance: "kb-cron"
+---
+
+In program analysis, a polyvariant or context-sensitive analysis (as opposed to a monovariant or context-insensitive analysis) analyzes each function multiple times—typically once at each call site—to improve the precision of the analysis. Polyvariance is common in data-flow and pointer analyses.
+Forms of polyvariance include:
+
+Call-site sensitivity
+The Cartesian product algorithm
+Object sensitivity
+Type sensitivity
+The first two are more often used for dataflow analyses, the latter two are more frequently used for pointer analyses.
+
+
+== References ==
+
+
+=== Sources ===
+Smaragdakis, Yannis; Balatsouras, George (2015). "Pointer Analysis" (PDF). Foundations and Trends in Programming Languages. 2 (1): 1–69. doi:10.1561/2500000014. Retrieved May 30, 2019.
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Portable_object_(computing)-0.md b/data/en.wikipedia.org/wiki/Portable_object_(computing)-0.md
new file mode 100644
index 000000000..011f041d9
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Portable_object_(computing)-0.md
@@ -0,0 +1,18 @@
+---
+title: "Portable object (computing)"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Portable_object_(computing)"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:37:25.580772+00:00"
+instance: "kb-cron"
+---
+
+In distributed programming, a portable object is an object which can be accessed through a normal method call while possibly residing in memory on another computer.  It is portable in the sense that it moves from machine to machine, irrespective of operating system or computer architecture.  This mobility is the end goal of many remote procedure call systems.
+An advantage of portable objects is that they are easy to use and expressive, allowing programmers to be completely unaware that objects reside in other locations.  Detractors cite this as a fault, as some programmers will not expect network-related errors or the unbounded nondeterminism associated with large networks.
+
+
+== See also ==
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Presentation_semantics-0.md b/data/en.wikipedia.org/wiki/Presentation_semantics-0.md
new file mode 100644
index 000000000..d9100f3d1
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Presentation_semantics-0.md
@@ -0,0 +1,16 @@
+---
+title: "Presentation semantics"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Presentation_semantics"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:37:26.770483+00:00"
+instance: "kb-cron"
+---
+
+In computer science, particularly in human-computer interaction, presentation semantics specify how a particular piece of a formal language is represented in a distinguished manner accessible to human senses, usually human vision. For example, saying that <bold> ... </bold> must render the text between these constructs using some bold typeface is a specification of presentation semantics for that syntax.
+Many markup languages, including HTML, DSSSL, and XSL-FO, have presentation semantics, but others, such as XML, do not. Character encoding standards, such as Unicode, also have presentation semantics.
+One of the main goals of style sheet languages is to separate the syntax that defines document content from the syntax endowed with presentation semantics. This is the norm on the World Wide Web, where the Cascading Style Sheets language provides a large collection of presentation semantics for HTML documents.
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Principal_(computer_security)-0.md b/data/en.wikipedia.org/wiki/Principal_(computer_security)-0.md
new file mode 100644
index 000000000..d2e22e063
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Principal_(computer_security)-0.md
@@ -0,0 +1,22 @@
+---
+title: "Principal (computer security)"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Principal_(computer_security)"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:37:27.985249+00:00"
+instance: "kb-cron"
+---
+
+A principal in computer security is an entity that can be authenticated by a computer system or network. It is referred to as a security principal in Java and Microsoft literature.
+Principals can be individual people, computers, services, computational entities such as processes and threads, or any group of such things. They need to be identified and authenticated before they can be assigned rights and privileges over resources in the network. A principal typically has an associated identifier (such as a security identifier) that allows it to be referenced for identification or assignment of properties and permissions.
+A principal often becomes synonymous with the credentials used to act as that principal, such as a password or (for service principals) an access token or other secrets.
+
+
+== References ==
+
+
+== External links ==
+RFC 2744 - Generic Security Service API Version 2.
+RFC 5397 - WebDAV Current Principal Extension.
+RFC 4121 - The Kerberos Version 5 Generic Security Service Application Program Interface (GSS-API) Mechanism: Version 2.
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Prioritised_Petri_net-0.md b/data/en.wikipedia.org/wiki/Prioritised_Petri_net-0.md
new file mode 100644
index 000000000..51558da9d
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Prioritised_Petri_net-0.md
@@ -0,0 +1,19 @@
+---
+title: "Prioritised Petri net"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Prioritised_Petri_net"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:37:29.153499+00:00"
+instance: "kb-cron"
+---
+
+A Prioritised Petri net is a structure (PN, Π) where PN is a Petri net and Π is a priority function that maps transitions into non-negative natural numbers representing their priority level 
+The enabled transitions with a given priority k always fire before any other enabled transition with priority j<k.
+
+
+== References ==
+
+
+== Sources ==
+B. Hruz, M.C.Zhou, "Modeling and Control of Discrete-event Dynamic Systems with Petri Nets and Other Tool", Advanced Control and signal processing, Springer, 2007
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Priority_inheritance-0.md b/data/en.wikipedia.org/wiki/Priority_inheritance-0.md
new file mode 100644
index 000000000..cb4eb3121
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Priority_inheritance-0.md
@@ -0,0 +1,45 @@
+---
+title: "Priority inheritance"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Priority_inheritance"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:37:30.382209+00:00"
+instance: "kb-cron"
+---
+
+In real-time computing, priority inheritance is a method for eliminating unbounded priority inversion. Using this programming method, a process scheduling algorithm increases the priority of a process (A) to the maximum priority of any other process waiting for any resource on which A has a resource lock (if it is higher than the original priority of A).
+The basic idea of the priority inheritance protocol is that when a job blocks one or more high-priority jobs, it ignores its original priority assignment and executes its critical section at an elevated priority level. After executing its critical section and releasing its locks, the process returns to its original priority level.
+
+
+== Example ==
+Consider three jobs:
+
+Suppose that both H and L require some shared resource. If L acquires this shared resource (entering a critical section), and H subsequently requires it, H will block until L releases it (leaving its critical section). Without priority inheritance, process M could preempt process L during the critical section and delay its completion, in effect causing the lower-priority process M to indirectly preempt the high-priority process H. This is a priority inversion bug.
+With priority inheritance, L will execute its critical section at H's high priority whenever H is blocked on the shared resource. As a result, M will be unable to preempt L and will be blocked. That is, the higher-priority job M must wait for the critical section of the lower priority job L to be executed, because L has inherited H's priority. When L exits its critical section, it regains its original (low) priority and awakens H (which was blocked by L). H, having high priority, preempts L and runs to completion. This enables M and L to resume in succession and run to completion without priority inversion.
+
+
+== Operating systems supporting priority inheritance ==
+Windows
+Linux
+ERIKA Enterprise
+FreeRTOS
+Eclipse ThreadX
+VxWorks
+iRMX
+
+
+== See also ==
+Priority ceiling protocol
+
+
+== References ==
+Lui Sha; Ragunathan Rajkumar & John P. Lehoczky (September 1990). "Priority Inheritance Protocols: An Approach to Real-Time Synchronization" (PDF). IEEE Transactions on Computers. 39 (9): 1175–1185. doi:10.1109/12.57058. Archived from the original (PDF) on 2022-04-19.
+
+
+== External links ==
+"Priority Inheritance: The Real Story" by Doug Locke
+"Against Priority Inheritance" by Victor Yodaiken
+"Implementing Concurrency Control With Priority Inheritance in Real-Time CORBA" by Steven Wohlever, Victor Fay Wolfe and Russell Johnston
+"Priority Inheritance Spin Locks for Multiprocessor Real-Time Systems" by Cai-Dong Wang, Hiroaki Takada and Ken Sakamura
+"Hardware Support for Priority Inheritance" by Bilge E. S. Akgul, Vincent J. Mooney, Henrik Thane and Pramote Kuacharoen
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/ProCoS-0.md b/data/en.wikipedia.org/wiki/ProCoS-0.md
new file mode 100644
index 000000000..5082300c8
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/ProCoS-0.md
@@ -0,0 +1,41 @@
+---
+title: "ProCoS"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/ProCoS"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:37:31.554020+00:00"
+instance: "kb-cron"
+---
+
+ProCoS ("Provably Correct Systems") was a European ESPRIT initiative of two collaborative computer science research projects and a Working Group, with further associated international liaison funding, started in 1989 and ending in 1997.
+The projects aimed to connect computer-based systems in a formal manner at different levels of abstraction, including requirements, specifications, programs, through compilation, to machine code, and even directly into hardware described by netlists, based around the occam programming language and the Transputer
+processor.
+A major research output of the project was Duration Calculus by Zhou Chaochen, Tony Hoare, and Anders P. Ravn.
+A later result of the project was Unifying Theories of Programming (UTP) by Tony Hoare and He Jifeng.
+
+
+== Projects and grants ==
+The following projects and associated collaborations were funded:
+
+ESPRIT ProCoS BRA (Basic Research Action) project (no. 3104, 1989–1992)
+ESPRIT ProCoS II project (no. 7071, 1992–1995)
+ESPRIT ProCoS-WG Working Group (no. 8694, 1994–1997)
+UK EPSRC Provably Correct Hardware/Software Co-design project (1993–1996)
+ESPRIT/NSF ProCoS-US (EC-US027, 1993–1997) European/United States travel grant on Provably Correct Hardware Compilation
+ESPRIT KIT (Keep in Touch) travel grant (1993–1996) with Zhou Chaochen, UNU-IIST (Macau)
+ESPRIT PROCORSYS KIT (Keep in Touch) travel grant (KIT 142, 1994–1997) with Augusto Sampaio, Departamento de Informatica, Universidade Federal de Pernambuco (Brazil)
+UK EPSRC Visiting Fellowship (1996–1997) to study Provably Correct Real-Time Systems for Michael Schenke, Oldenburg University (Germany)
+
+
+== Partners ==
+The main project partners, among others, were:
+
+Technical University of Denmark – DTU (Denmark)
+Kiel University (Germany)
+University of Oldenburg (Germany)
+University of Oxford (United Kingdom)
+A two-day reunion meeting was held at the BCS London office in March 2015.
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Program_dependence_graph-0.md b/data/en.wikipedia.org/wiki/Program_dependence_graph-0.md
new file mode 100644
index 000000000..cac6fc2e1
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Program_dependence_graph-0.md
@@ -0,0 +1,22 @@
+---
+title: "Program dependence graph"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Program_dependence_graph"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:37:32.740410+00:00"
+instance: "kb-cron"
+---
+
+A Program Dependence Graph (PDG) is a directed graph of a program's control and data dependencies. Nodes represent program statements and edges represent dependencies between these statements.
+PDGs are used in optimization, debugging, and understanding program behavior. One example of this is their utilization by compilers during dependence analysis, enabling the optimizing compiler to make transformations to allow for parallelism.
+
+
+== See also ==
+Dependency graph
+Control-flow graph
+Data-flow analysis
+Static program analysis
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Program_transformation-0.md b/data/en.wikipedia.org/wiki/Program_transformation-0.md
new file mode 100644
index 000000000..d183f9ce4
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Program_transformation-0.md
@@ -0,0 +1,38 @@
+---
+title: "Program transformation"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Program_transformation"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:37:33.930422+00:00"
+instance: "kb-cron"
+---
+
+A program transformation is any operation that takes a computer program and generates another program. In many cases the transformed program is required to be semantically equivalent to the original, relative to a particular formal semantics and in fewer cases the transformations result in programs that semantically differ from the original in predictable ways.
+While the transformations can be performed manually, it is often more practical to use a program transformation system that applies specifications of the required transformations. Program transformations may be specified as automated procedures that modify compiler data structures (e.g. abstract syntax trees) representing the program text, or may be specified more conveniently using patterns or templates representing parameterized source code fragments.
+A practical requirement for source code transformation systems is that they be able to effectively process programs written in a programming language. This usually requires integration of a full front-end for the programming language of interest, including source code parsing, building internal program representations of code structures, the meaning of program symbols, useful static analyses, and regeneration of valid source code from transformed program representations. The problem of building and integrating adequate front ends for conventional languages (Java, C++, PHP etc.) may be of equal difficulty as building the program transformation system itself because of the complexity of such languages. To be widely useful, a transformation system must be able to handle many target programming languages, and must provide some means of specifying such language-specific front-ends.
+A generalisation of semantic equivalence is the notion of program refinement: one program is a refinement of another if it terminates on all the initial states for which the original program terminates, and for each such state it is guaranteed to terminate in a possible final state for the original program. In other words, a refinement of a program is more defined and more deterministic than the original program. If two programs are refinements of each other, then the programs are equivalent.
+
+
+== See also ==
+List of program transformation systems
+Metaprogramming
+Program synthesis
+Source-to-source compiler
+Source code generation
+Transformation language
+Transformational grammar
+Dynamic recompilation
+Operation reduction for low power
+
+
+== References ==
+
+
+== External links ==
+The Program transformation Wiki
+Papers on program transformation theory and practicE
+Transformation Technology Bibliography
+DMS Software Reengineering Toolkit: A Program Transformation System for DSLs and modern (C++, Java, ...) and legacy (COBOL, RPG) computer languages
+Spoon: A library to analyze, transform, rewrite, and transpile Java source code. It parses source files to build a well-designed AST with powerful analysis and transformation API.
+JavaParser: The JavaParser library provides you with an Abstract Syntax Tree of your Java code. The AST structure then allows you to work with your Java code in an easy programmatic way..
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Progressive_disclosure-0.md b/data/en.wikipedia.org/wiki/Progressive_disclosure-0.md
new file mode 100644
index 000000000..1a14ced42
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Progressive_disclosure-0.md
@@ -0,0 +1,26 @@
+---
+title: "Progressive disclosure"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Progressive_disclosure"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:37:35.158821+00:00"
+instance: "kb-cron"
+---
+
+Progressive disclosure is an interaction design pattern used to make applications easier to learn and less error-prone. It does so by deferring some advanced or rarely-used features to a secondary screen and designing workflows where information is revealed when it becomes relevant to the current task.
+
+A classic example of this pattern is the print dialog in macOS. While printing a page, the print dialog shows only a small subset of choices. If the user wants more advanced options, they can click the "Show Details" button to reveal these features in a secondary screen.
+In the physical world, progressive disclosure is used by modern theme park designers. Long waiting lines for rides can scare away visitors, so only a small segment of the line is made visible from any vantage point. As people move ahead in line, they only get to see discrete portions of the entire line. This design can make waiting more bearable for those in line.
+
+
+== History ==
+Kristina Hooper Woolsey, a founding member of the Apple Human Interface Group, wrote in 1985 what could be considered as the seminal idea for selectively disclosing to new users how a system works:"In the design of interfaces one must also consider carefully how one selectively informs a user about a particular system, providing well-chosen bits and pieces that can constitute a general understanding of a system."
+
+
+== See also ==
+Disclosure widget
+Chunking (writing)
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Property_equivalence-0.md b/data/en.wikipedia.org/wiki/Property_equivalence-0.md
new file mode 100644
index 000000000..079052a55
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Property_equivalence-0.md
@@ -0,0 +1,25 @@
+---
+title: "Property equivalence"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Property_equivalence"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:37:36.353115+00:00"
+instance: "kb-cron"
+---
+
+In metadata, property equivalence is the statement that two properties have the same property extension or values.  This usually (but not always) implies that the two properties have the same semantics or meaning.   Technically it only implies that the data elements have the same values.
+Property equivalence is one of the three ways that a metadata registry can store equivalence mappings to other metadata registries.
+Note that property equivalence is not the same as property equality. Equivalent properties have the same "values" (i.e., the same property extension), but may have different intensional meaning (i.e., denote different concepts). Property equality should be expressed with the owl:sameAs construct. As this requires that properties are treated as individuals, such axioms are only allowed in OWL Full.
+
+
+== See also ==
+Metadata registry
+Web ontology language
+Class equivalence
+Synonym Ring
+
+
+== External links ==
+OWL equivalent property definition
+OWL same as definition
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Proportional_share_scheduling-0.md b/data/en.wikipedia.org/wiki/Proportional_share_scheduling-0.md
new file mode 100644
index 000000000..796350a9f
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Proportional_share_scheduling-0.md
@@ -0,0 +1,14 @@
+---
+title: "Proportional share scheduling"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Proportional_share_scheduling"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:37:37.575379+00:00"
+instance: "kb-cron"
+---
+
+Proportional share scheduling is a type of scheduling that preallocates certain amount of CPU time to each of the processes. In a proportional share algorithm every job has a weight, and jobs receive a share of the available resources proportional to the weight of every job.
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Protected_procedure-0.md b/data/en.wikipedia.org/wiki/Protected_procedure-0.md
new file mode 100644
index 000000000..f132d31a3
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Protected_procedure-0.md
@@ -0,0 +1,22 @@
+---
+title: "Protected procedure"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Protected_procedure"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:37:38.783922+00:00"
+instance: "kb-cron"
+---
+
+In computer science, the concept of protected procedure, first introduced as protected service routine in 1965, is necessary when two computations A and B use the same routine S; a protected procedure is such if makes not possible for a malfunction of one of the two computation to cause incorrect execution to the other.
+One of the most important aspects of Dennis and Van Horn (hypothetical) system "supervisor" was the inclusion of a description of protected procedure.
+In a global environment system (where there's some shared variable), the protected procedure mechanism allows the enforcement of the principle of least privilege and the avoidance of side effects in resources management (see Denning principles).
+
+
+== Footnotes ==
+
+
+== References ==
+Dennis, J. B., and Glasee, E. The structure of on-line information processing systems. Information Systems Sciences: Proc. Second Cong., Spartan Books, Baltimore, 1965, pp. 1–11
+J. B. Dennis and E. C. Van Horn. Programming Semantics for Multiprogrammed Computations. Communications of the ACM 9(3), March 1966.
+Levy, Henry M. (1984). "3". Capability-based computer systems. Maynard, Mass: Digital Press. ISBN 0-932376-22-3.
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Pseudo-LRU-0.md b/data/en.wikipedia.org/wiki/Pseudo-LRU-0.md
new file mode 100644
index 000000000..f8ac23e37
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Pseudo-LRU-0.md
@@ -0,0 +1,36 @@
+---
+title: "Pseudo-LRU"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Pseudo-LRU"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:37:39.937555+00:00"
+instance: "kb-cron"
+---
+
+Pseudo-LRU or PLRU is a family of cache algorithms which improve on the performance of the Least Recently Used (LRU) algorithm by replacing values using approximate measures of age rather than maintaining the exact age of every value in the cache.
+PLRU usually refers to two cache replacement algorithms: tree-PLRU and bit-PLRU.
+
+
+== Tree-PLRU ==
+Tree-PLRU is an efficient algorithm to select an item that most likely has not been accessed very recently, given a set of items and a sequence of access events to the items.
+This technique is used in the CPU cache of the Intel 486 and in many processors in the PowerPC family, such as Freescale's PowerPC G4 used by Apple Computer.
+The algorithm works as follows: consider a binary search tree for the items in question. Each node of the tree has a one-bit flag denoting "go left to insert a pseudo-LRU element" or "go right to insert a pseudo-LRU element". To find a pseudo-LRU element, traverse the tree according to the values of the flags. To update the tree with an access to an item N, traverse the tree to find N and, during the traversal, set the node flags to denote the direction that is opposite to the direction taken.
+
+This algorithm can be sub-optimal since it is an approximation. For example, in the above diagram with A, C, B, D cache lines, if the access pattern was: C, B, D, A, on an eviction, B would be chosen instead of C. This is because both A and C are in the same half and accessing A directs the algorithm to the other half that does not contain cache line C.
+
+
+== Bit-PLRU ==
+Bit-PLRU stores one status bit for each cache line.  These bits are called MRU-bits. Every access to a line sets its MRU-bit to 1, indicating that the
+line was recently used. Whenever the last remaining 0 bit of a set's status bits is
+set to 1, all other bits are reset to 0. At cache misses, the leftmost line whose MRU-bit is 0 is replaced.
+
+
+== See also ==
+Cache algorithms
+
+
+== References ==
+https://people.cs.clemson.edu/~mark/464/p_lru.txt
+http://www.ipdps.org/ipdps2010/ipdps2010-slides/session-22/2010IPDPS.pdf
+http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.217.3594&rep=rep1&type=pdf
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Pseudoconversational_transaction-0.md b/data/en.wikipedia.org/wiki/Pseudoconversational_transaction-0.md
new file mode 100644
index 000000000..08d592909
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Pseudoconversational_transaction-0.md
@@ -0,0 +1,27 @@
+---
+title: "Pseudoconversational transaction"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Pseudoconversational_transaction"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:37:41.135432+00:00"
+instance: "kb-cron"
+---
+
+In transaction processing, a pseudoconversational transaction is a type of transaction that emulates a true conversation in an interactive session. To the end user, it appears as though the program has simply "paused" to request further input, whereas in reality, most resources are released while the input is waiting to be received.
+
+
+== Transparent termination and restart ==
+The controlling program has deliberately saved most of its state during the delay, terminated, and then, on being restarted through new input, restores its previous state. A single control variable is usually retained to hold the current state in terms of the stage of input reached (and therefore what must be recovered at any stage in order to resume processing). The state, including the control variable, is usually preserved in a 'temporary storage record' that maps the variables needing restoration as an aggregate set, usually contained in a single structure (other variables will be re-initialized on restart).
+
+
+== Conserving resources ==
+This method of programming frees up pooled resources (such as memory) for an indeterminate time. This delay is the end-user 'thinking time' (or response time) and depends on human factors including speed of typing.
+For systems supporting many thousands of users on a single processor, it allows the transparent 'look and feel' of a true conversational session without tying up limited resources.
+
+
+== References ==
+
+
+== External links ==
+Pseudoconversational and conversational design by IBM
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/QCP_(file_format)-0.md b/data/en.wikipedia.org/wiki/QCP_(file_format)-0.md
new file mode 100644
index 000000000..e2524bc9d
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/QCP_(file_format)-0.md
@@ -0,0 +1,20 @@
+---
+title: "QCP (file format)"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/QCP_(file_format)"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:37:43.721100+00:00"
+instance: "kb-cron"
+---
+
+The QCP file format is used by many cellular telephone manufacturers to provide ring tones and record voice.  It is based on RIFF, a generic format for storing chunks of data identified by tags.  The QCP format does not specify how voice data in the file is encoded.  Rather, it is a container format. QCP files are typically encoded QCELP or EVRC.
+Qualcomm, which originated the format, has removed an internal web page link from the page that formerly discussed QCP.  "Out of an abundance of caution, due to the December 31st, 2007 injunction ordered against certain Qualcomm products, Qualcomm has temporarily removed certain web content until it can be reviewed and modified if necessary to ensure compliance with the injunction. It may be several more days or weeks before these pages are accessible again. Thank you for your patience."
+QCP files have the same signature as RIFF files: A SOF (start of file) header of 52494646 ("RIFF"), and an EOF (end of file) of 0000.
+
+
+== Playing QCP files ==
+Qualcomm previously offered downloads of the software and SDK for its PureVoice voice and audio enhancement products that could play and convert QCP files.
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/QNX4FS-0.md b/data/en.wikipedia.org/wiki/QNX4FS-0.md
new file mode 100644
index 000000000..b3528bae5
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/QNX4FS-0.md
@@ -0,0 +1,20 @@
+---
+title: "QNX4FS"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/QNX4FS"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:37:44.896921+00:00"
+instance: "kb-cron"
+---
+
+QNX4FS is an extent-based file system used by the QNX4 and QNX6 operating systems.
+As the file system uses soft updates, it remains consistent even after a power failure, without using journaling. Instead, the writes are carefully ordered and flushed to disk at appropriate intervals so that the on-disk structure always remains consistent, no matter if the operation is interrupted. However, unflushed changes to the file system  are nevertheless lost, as the disk cache is typically stored in volatile memory.
+Another notable property of this file system is that its actual metadata, like inode information and disk bitmaps, are accessible in the same way as any other file on the file system (as /.inodes and /.bitmap, respectively). This is consistent with QNX's (in fact, Plan 9 from Bell Labs's, or historically Unix's) philosophy that "everything is a file".
+
+
+== References ==
+
+
+== External links ==
+Official website
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Quaject-0.md b/data/en.wikipedia.org/wiki/Quaject-0.md
new file mode 100644
index 000000000..2154de776
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Quaject-0.md
@@ -0,0 +1,16 @@
+---
+title: "Quaject"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Quaject"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:37:46.084940+00:00"
+instance: "kb-cron"
+---
+
+In computer science, a quaject is an object-like data structure containing both data and code (or pointers to code), exposed as an interface in the form of callentries, and can accept a list of callentries to other quajects for callbacks and callouts. They were developed by Alexia Massalin in 1989 for the Synthesis kernel, and named for the Qua! Machine, a unique hardware platform built by Massalin. The origin of the term 'qua' is unclear; Massalin claims humorously that it is a sound made by koalas.
+The main purpose of quajects is to provide an abstraction to manage self-modifying code, by allowing runtime code optimizing on a per-object basis. While the original Synthesis kernel required quajects to be written in hand-developed assembly language, this was done to avoid developing a complex compiler; Massalin noted that just-in-time compilation (JIT) for a high-level programming language that permits runtime code generation, as in Lisp or Smalltalk, can also apply this approach, though she also asserted that the complexity of such a compiler was likely to be prohibitive.
+Quajects differ from more conventional objects in two key ways: first, they always use a form of the dependency injection pattern to manage both interfaces to other quajects, and continuations out of the quaject; the list of callentry references for this is part of quaject creation, and may be updated during the quaject's lifetime. Second, and more critically, a given quaject's set of methods can be unique to the specific quaject; methods for a type or class of quajects are stored as one or more templates, rather than as fixed code. While shared methods can be accessed through a common table of pointers, individual quajects can also have methods that are generated specifically to tailor the performance for that quaject's behavior.
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Qualification_principle-0.md b/data/en.wikipedia.org/wiki/Qualification_principle-0.md
new file mode 100644
index 000000000..464baf9a9
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Qualification_principle-0.md
@@ -0,0 +1,22 @@
+---
+title: "Qualification principle"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Qualification_principle"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:37:47.254333+00:00"
+instance: "kb-cron"
+---
+
+In programming language theory, the qualification principle states that any semantically meaningful syntactic class may admit local definitions. In other words, it's possible to include a block in any syntactic class, provided that the phrases of that class specify some kind of computation. (Watt 1990)
+A common examples for of this principle includes:
+
+block command -- a command containing a local declaration, which is used only for executing this command. In the following excerpt from a C program, tmp variable declared is local to the surrounding block command:
+
+block expression -- an expression containing a local declaration, which is used only for evaluating this expression. In the following excerpt from ML program, local declaration of g can be used only during evaluation of the following expression:
+
+block declaration is one containing a local declaration, the bindings produced by which are used only for elaborating the block declaration. In the following excerpt from ML program, local declaration of function leap, using an auxiliary function multiple:
+
+
+== References ==
+Watt, David A. (1990) [1990]. "Bindings". Programming Language Concepts and Paradigms. Prentice Hall. pp. 82–83. ISBN 0-13-728874-3.
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Qualified_Security_Assessor-0.md b/data/en.wikipedia.org/wiki/Qualified_Security_Assessor-0.md
new file mode 100644
index 000000000..167670c72
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Qualified_Security_Assessor-0.md
@@ -0,0 +1,21 @@
+---
+title: "Qualified Security Assessor"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Qualified_Security_Assessor"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:37:48.423871+00:00"
+instance: "kb-cron"
+---
+
+Qualified Security Assessor (QSA) is a designation conferred by the PCI Security Standards Council to those individuals that meet specific information security education requirements, have taken the appropriate training from the PCI Security Standards Council, are employees of a Qualified Security Assessor (QSA) company approved PCI security and auditing firm, and will be performing PCI compliance assessments as they relate to the protection of credit card data.
+The term QSA can be implied to identify an individual qualified to perform payment card industry compliance auditing and consulting or the firm itself. QSA companies are sometimes differentiated from QSA individuals by the initialism 'QSAC'.
+The primary goal of an individual with the PCI QSA certification is to perform an assessment of a firm that handles credit card data against the high-level control objectives of the PCI Data Security Standard (PCI DSS).
+Consultants holding the QSA certification must re-certify annually to ensure they are conversant with any changes to the PCI-DSS requirements and guidelines.
+
+
+== References ==
+
+
+== External links ==
+PCI Security Standards Council
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Queries_per_second-0.md b/data/en.wikipedia.org/wiki/Queries_per_second-0.md
new file mode 100644
index 000000000..b23828285
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Queries_per_second-0.md
@@ -0,0 +1,19 @@
+---
+title: "Queries per second"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Queries_per_second"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:37:49.614549+00:00"
+instance: "kb-cron"
+---
+
+Queries per second (QPS) is a measure of the amount of search traffic an information-retrieval system, such as a search engine or a database, receives in one second. The term is used more broadly for any request–response system, where it can more correctly be called requests per second (RPS).
+High-traffic systems must be mindful of QPS to know when to scale to handle greater load.
+
+
+== See also ==
+Transactions per second
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/RDF/XML-0.md b/data/en.wikipedia.org/wiki/RDF/XML-0.md
new file mode 100644
index 000000000..6be164d5b
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/RDF/XML-0.md
@@ -0,0 +1,21 @@
+---
+title: "RDF/XML"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/RDF/XML"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:37:52.005646+00:00"
+instance: "kb-cron"
+---
+
+RDF/XML is a syntax, defined by the W3C, to express (i.e., serialize) an RDF graph as an XML document. RDF/XML is sometimes misidentified as simply RDF because it was introduced alongside the other W3C specifications defining RDF and was historically the first W3C official RDF serialization format. 
+RDF/XML is the primary exchange syntax for OWL 2, and must be supported by all OWL 2 tools.
+
+
+== References ==
+
+
+== External links ==
+RDF/XML Syntax Specification
+RDF Primer
+RFC 3870: application/rdf+xml Media Type Registration
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Raster_Document_Object-0.md b/data/en.wikipedia.org/wiki/Raster_Document_Object-0.md
new file mode 100644
index 000000000..da8b51e57
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Raster_Document_Object-0.md
@@ -0,0 +1,24 @@
+---
+title: "Raster Document Object"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Raster_Document_Object"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:37:50.779249+00:00"
+instance: "kb-cron"
+---
+
+The .RDO (Raster Document Object) file format is the native format used by Xerox's DocuTech range of hardware and software, that underpins the company's Xerox Document On Demand (XDOD) systems. It is therefore a significant file format for the print on demand market sector, along with PostScript and Portable Document Format.
+RDO is a metafile format based on the Open Document Architecture (ODA) specifications:  In Xerox's RDO implementation, description and control information is stored within the RDO file, while raster images are stored separately, usually in a separate folder, as TIFF files. The RDO file dictates which bitmap images will be used on each page of a document, and where they will be placed.
+
+
+== Features and disadvantages ==
+This approach has advantages and disadvantages over the monolithic approach used by PDF: 
+The disadvantages of RDO are that it is a largely proprietary format, and the multi-file approach means that file management and orphan control is more of an issue: one cannot tell from a computer's file system whether all the files required for a document to print are present and correct. 
+In RDO's favor, the multi-file approach allows a networked device to load the small RDO file and then request the larger bitmap files only when necessary: This allows a full job specification to be loaded and installed over a network almost immediately, with the larger bitmap files only having to be transferred as and when needed, allowing more flexibility for managing network traffic loading.    
+The TIFF file format is highly portable, and Xerox's MakeReady software, supplied with its XDOD systems, readily imports and export postscript files: however, the Xerox "on demand" systems typically require a document library to be stored as RDO / TIFF files, and most non-Xerox applications will not read RDO structures directly.
+
+
+== References ==
+"Document encoding formats for Phoenix: an example of on-demand publishing" - Summary Report prepared by South Bank University
+Oya Y. Rieger and Anne R. Kenney "Risk Management of Digital Information Case Study for Image File Format"
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Re-order_buffer-0.md b/data/en.wikipedia.org/wiki/Re-order_buffer-0.md
new file mode 100644
index 000000000..1e305c6a0
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Re-order_buffer-0.md
@@ -0,0 +1,29 @@
+---
+title: "Re-order buffer"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Re-order_buffer"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:37:53.177245+00:00"
+instance: "kb-cron"
+---
+
+A re-order buffer (ROB) is a hardware unit used in an extension to Tomasulo's algorithm to support out-of-order and speculative instruction execution.  The extension forces instructions to be committed in-order.
+The buffer is a circular buffer (to provide a FIFO instruction ordering queue) implemented as an array/vector (which allows recording of results against instructions as they complete out of order).
+There are three stages to the Tomasulo algorithm: "Issue", "Execute", "Write Result". In an extension to the algorithm, there is an additional "Commit" stage. During the Commit stage, instruction results are stored in a register or memory. The "Write Result" stage is modified to place results in the re-order buffer. Each instruction is tagged in the reservation station with its index in the ROB for this purpose.
+The contents of the buffer are used for data dependencies of other instructions scheduled in the buffer. The head of the buffer will be committed once its result is valid. Its dependencies will have already been calculated and committed since they must be ahead of the instruction in the buffer though not necessarily adjacent to it. Data dependencies between instructions would normally stall the pipeline while an instruction waits for its dependent values. The ROB allows the pipeline to continue to process other instructions while ensuring results are committed in order to prevent data hazards such as Read after Write (RAW), Write after Read (WAR) and Write after Write (WAW). 
+There are additional fields in every entry of the buffer to support the extended algorithm:
+
+Instruction type (jump, store to memory, store to register)
+Destination (either memory address or register number)
+Result (value that goes to destination or indication of a (un)successful jump)
+Validity (does the result already exist?)
+The consequences of the re-order buffer include precise exceptions and easy rollback control of target address mis-predictions (branch or jump). When jump prediction is not correct or a nonrecoverable exception is encountered in the instruction stream, the ROB is cleared of all instructions (by setting the circular queue tail to the head) and reservation stations are re-initialized.
+
+
+== References ==
+
+
+== External links ==
+Hardware Based Speculation - Prof. Dr. Ben H. Juurlink
+Reorder Buffer
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Read–modify–write-0.md b/data/en.wikipedia.org/wiki/Read–modify–write-0.md
new file mode 100644
index 000000000..0f0f02316
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Read–modify–write-0.md
@@ -0,0 +1,23 @@
+---
+title: "Read–modify–write"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Read–modify–write"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:37:54.396394+00:00"
+instance: "kb-cron"
+---
+
+In computer science, read–modify–write is a class of atomic operations (such as test-and-set, fetch-and-add, and compare-and-swap) that both read a memory location and write a new value into it simultaneously, either with a completely new value or some function of the previous value.  These operations prevent race conditions in multi-threaded applications. Typically they are used to implement mutexes or semaphores.  These atomic operations are also heavily used in non-blocking synchronization.
+Read–modify–write instructions often produce unexpected results when used on I/O devices, as a write operation may not affect the same internal register that would be accessed in a read operation. This term is also associated with RAID levels that perform actual write operations as atomic read–modify–write sequences.  Such RAID levels include RAID 4, RAID 5 and RAID 6.
+
+
+== Consensus number ==
+
+
+== See also ==
+Linearizability
+Read–erase–modify–write
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Real-time_Programming_Language-0.md b/data/en.wikipedia.org/wiki/Real-time_Programming_Language-0.md
new file mode 100644
index 000000000..1d8bdab27
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Real-time_Programming_Language-0.md
@@ -0,0 +1,16 @@
+---
+title: "Real-time Programming Language"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Real-time_Programming_Language"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:37:56.821100+00:00"
+instance: "kb-cron"
+---
+
+Real-time Programming Language (RPL) is a compiled database programming language used on CMC/Microdata/McDonnell Douglas REALITY databases, derived and expanded from the PROC procedure language, with much extra functionality added.  It was originally developed under the name "PORC" by John Timmons and Paul Desjardins in about 1975.  "PORC" was then further developed by Tim Holland under the employ of George Ridgway's company Systems Management, Inc. (SMI) in Chicago.  A number of large scale manufacturing applications were developed in RPL, including that which was in use at Plessey and GEC-Plessey Telecommunications limited in Liverpool and also the Trifid suite of manufacturing software.
+
+
+== Sources ==
+RPL 1.3 Reference Manual (PDF)
+"Software House Puts Emphasis on Nitty-Gritty", 10 Sep 1979.
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Real_computation-0.md b/data/en.wikipedia.org/wiki/Real_computation-0.md
new file mode 100644
index 000000000..e1b32c4f9
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Real_computation-0.md
@@ -0,0 +1,31 @@
+---
+title: "Real computation"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Real_computation"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:37:55.588825+00:00"
+instance: "kb-cron"
+---
+
+In computability theory, the theory of real computation deals with hypothetical computing machines using infinite-precision real numbers. They are given this name because they operate on the set of real numbers. Within this theory, it is possible to prove interesting statements such as "The complement of the Mandelbrot set is only partially decidable."
+These hypothetical computing machines can be viewed as idealised analog computers which operate on real numbers, whereas digital computers are limited to computable numbers. They may be further subdivided into differential and algebraic models (digital computers, in this context, should be thought of as topological, at least insofar as their operation on computable reals is concerned). Depending on the model chosen, this may enable real computers to solve problems that are inextricable on digital computers, or vice versa. For example, Hava Siegelmann's neural nets can have noncomputable real weights, making them able to compute nonrecursive languages. Claude Shannon's idealized analog computer can only solve algebraic differential equations, while a digital computer can solve some transcendental equations as well. However this comparison is not entirely fair since in Claude Shannon's idealized analog computer computations are immediately done; i.e. computation is done in real time. Shannon's model can be adapted to cope with this problem.
+A canonical model of computation over the reals is the Blum–Shub–Smale machine (BSS).
+If real computation were physically realizable, one could use it to solve NP-complete problems, and even #P-complete problems, in polynomial time. Unlimited precision real numbers in the physical universe are prohibited by the holographic principle and the Bekenstein bound.
+
+
+== See also ==
+Hypercomputation, for other such powerful machines.
+Real RAM.
+Quantum finite automaton, for a generalization to arbitrary geometrical spaces.
+
+
+== References ==
+
+
+== Further reading ==
+Lenore Blum, Felipe Cucker, Michael Shub, and Stephen Smale (1998). Complexity and Real Computation. Springer. ISBN 0-387-98281-7.{{cite book}}:  CS1 maint: multiple names: authors list (link)
+Campagnolo, Manuel Lameiras (July 2001). Computational complexity of real valued recursive functions and analog circuits. Universidade Técnica de Lisboa, Instituto Superior Técnico.
+Natschläger, Thomas, Wolfgang Maass, Henry Markram. The "Liquid Computer" A Novel Strategy for Real-Time Computing on Time Series (PDF).{{cite book}}:  CS1 maint: multiple names: authors list (link)
+Siegelmann, Hava (December 1998). Neural Networks and Analog Computation: Beyond the Turing Limit. Springer. ISBN 0-8176-3949-7.
+Siegelmann, Hava T.; Sontag, Eduardo D. (1995). "On the computational power of neural nets" (PDF). Journal of Computer and System Sciences. 50 (1): 132–150. doi:10.1006/jcss.1995.1013. MR 1322637.
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Recursive_join-0.md b/data/en.wikipedia.org/wiki/Recursive_join-0.md
new file mode 100644
index 000000000..c04eefd9a
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Recursive_join-0.md
@@ -0,0 +1,24 @@
+---
+title: "Recursive join"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Recursive_join"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:37:58.015195+00:00"
+instance: "kb-cron"
+---
+
+The recursive join is an operation used in relational databases, also sometimes called a "fixed-point join". It is a compound operation that involves repeating the join operation, typically accumulating more records each time, until a repetition makes no change to the results (as compared to the results of the previous iteration).
+For example, if a database of family relationships is to be searched, and the record for each person has "mother" and "father" fields, a recursive join would be one way to retrieve all of a person's known ancestors: first the person's direct parents' records would be retrieved, then the parents' information would be used to retrieve the grandparents' records, and so on until no new records are being found.
+In this example, as in many real cases, the repetition involves only a single database table, and so is more specifically a "recursive self-join".
+Recursive joins can be very time-consuming unless optimized through indexing, the addition of extra key fields, or other techniques. Graph traversals come at a lower cost than the method of recursive joins.
+Recursive joins are highly characteristic of hierarchical data, and therefore become a serious issue with XML data. In XML, operations such as determining whether one element contains another are extremely common, and the recursive join is perhaps the most obvious way to implement them when the XML data is stored in a relational database.
+The standard way to define recursive joins in the SQL:1999 standard is by way of recursive common table expressions. Database management systems that support recursive CTEs include Microsoft SQL Server, Oracle, PostgreSQL and others.
+
+
+== See also ==
+Join
+Hierarchical and recursive queries in SQL
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Reflector_(cellular_automaton)-0.md b/data/en.wikipedia.org/wiki/Reflector_(cellular_automaton)-0.md
new file mode 100644
index 000000000..6786cc2c4
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Reflector_(cellular_automaton)-0.md
@@ -0,0 +1,26 @@
+---
+title: "Reflector (cellular automaton)"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Reflector_(cellular_automaton)"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:37:59.197641+00:00"
+instance: "kb-cron"
+---
+
+In cellular automata such as Conway's Game of Life, a reflector is a pattern that can interact with a spaceship to change its direction of motion, without damage to the reflector pattern. In Life, many oscillators can reflect the glider; there also exist stable reflectors composed of still life patterns that, when they interact with a glider, reflect the glider and return to their stable state.
+
+
+== Types ==
+As well as whether a reflector is a still life or an oscillator, a reflector might be characterised by the angle between the input and output spaceships (for example a 180° reflector would flip a spaceship). For most spaceships, this can only be 0°, 90°, or 180°. Another property is whether the reflector is colour preserving. That is, if it doesn't change the state of a spaceship as it gets reflected. If a reflector isn't colour preserving, it's known as colour changing.
+
+
+== Notes ==
+
+
+== References ==
+
+
+== External links ==
+New stable 180-degree glider reflector Archived 2012-02-22 at the Wayback Machine, Game of Life News, May 30, 2009
+New stable 90-degree glider reflector, Game of Life News, May 29, 2013
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Relationship_extraction-0.md b/data/en.wikipedia.org/wiki/Relationship_extraction-0.md
new file mode 100644
index 000000000..a3fa10145
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Relationship_extraction-0.md
@@ -0,0 +1,43 @@
+---
+title: "Relationship extraction"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Relationship_extraction"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:38:00.419017+00:00"
+instance: "kb-cron"
+---
+
+A relationship extraction task requires the detection and classification of semantic relationship mentions within a set of artifacts, typically from text or XML documents. The task is very similar to that of information extraction (IE), but IE additionally requires the removal of repeated relations (disambiguation) and generally refers to the extraction of many different relationships.
+
+
+== Concept and applications ==
+The concept of relationship extraction was first introduced during the 7th Message Understanding Conference in 1998. Relationship extraction involves the identification of relations between entities and it usually focuses on the extraction of binary relations. Application domains where relationship extraction is useful include gene-disease relationships, protein-protein interaction etc.
+Current relationship extraction studies use machine learning technologies, which approach relationship extraction as a classification problem. Never-Ending Language Learning is a semantic machine learning system developed by a research team at Carnegie Mellon University that extracts relationships from the open web.
+
+
+== Approaches ==
+There are several methods used to extract relationships and these include text-based relationship extraction. These methods rely on the use of pretrained relationship structure information or it could entail the learning of the structure in order to reveal relationships. Another approach to this problem involves the use of domain ontologies. There is also the approach that involves visual detection of meaningful relationships in parametric values of objects listed on a data table that shift positions as the table is permuted automatically as controlled by the software user. The poor coverage, rarity and development cost related to structured resources such as semantic lexicons (e.g. WordNet, UMLS) and domain ontologies (e.g. the Gene Ontology) has given rise to new approaches based on broad, dynamic background knowledge on the Web. For instance, the ARCHILES technique uses only Wikipedia and search engine page count for acquiring coarse-grained relations to construct lightweight ontologies.
+The relationships can be represented using a variety of formalisms/languages. One such representation language for data on the Web is RDF.
+More recently, end-to-end systems which jointly learn to extract entity mentions and their semantic relations have been proposed with strong potential to obtain high performance.
+Most of the reported systems have demonstrated their approach on English datasets.
+However, data and systems have been described for other languages, e.g., Russian
+and Vietnamese.
+
+
+== Datasets ==
+Researchers have constructed multiple datasets for benchmarking relationship extraction methods.
+One such dataset was the document-level relationship extraction dataset called DocRED released in 2019.
+It uses relations from Wikidata and text from the English Wikipedia.
+The dataset has been used by other researchers and a prediction competition has been setup at CodaLab.
+
+
+== See also ==
+Text analytics
+Semantic analytics
+Semantic role labeling
+Information extraction
+Business Intelligence
+
+
+== References ==
\ No newline at end of file
diff --git a/data/en.wikipedia.org/wiki/Relativistic_programming-0.md b/data/en.wikipedia.org/wiki/Relativistic_programming-0.md
new file mode 100644
index 000000000..15eb4e205
--- /dev/null
+++ b/data/en.wikipedia.org/wiki/Relativistic_programming-0.md
@@ -0,0 +1,23 @@
+---
+title: "Relativistic programming"
+chunk: 1/1
+source: "https://en.wikipedia.org/wiki/Relativistic_programming"
+category: "reference"
+tags: "science, encyclopedia"
+date_saved: "2026-05-05T11:38:01.589350+00:00"
+instance: "kb-cron"
+---
+
+Relativistic programming (RP) is a style of concurrent programming where instead of trying to avoid conflicts between readers and writers (or writers and writers in some cases) the algorithm is designed to tolerate them and get a correct result regardless of the order of events. Also, relativistic programming algorithms are designed to work without the presences of a global order of events. That is, there may be some cases where one thread sees two events in a different order than another thread (hence the term relativistic because in Einstein's theory of special relativity the order of events is not always the same to different viewers). This essentially implies working under causal consistency instead of a stronger model.
+Relativistic programming provides advantages in performance compared to other concurrency paradigms because it does not require one thread to wait for another nearly as often. Because of this, forms of it (Read-Copy-Update for instance) are now used extensively in the Linux kernel (over 18,000 times as of April 2021 and has grown from nothing to 11.8% of all locking primitives in just under two decades).
+
+
+== See also ==
+Non-blocking algorithm
+
+
+== References ==
+
+
+== External links ==
+Relativistic Programming at Portland State University
\ No newline at end of file