Scrape wikipedia-science: 10080 new, 3586 updated, 14027 total (kb-cron)
This commit is contained in:
parent
721764bf89
commit
a384fad753
@ -0,0 +1,26 @@
|
||||
---
|
||||
title: "EXperimental Computing Facility"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/EXperimental_Computing_Facility"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:33:38.277416+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
Founded in 1986, the eXperimental Computing Facility (XCF) is an undergraduate computing-interest organization at University of California, Berkeley. The "Experimental" description was given in contrast to the Open Computing Facility and the Computer Science Undergraduate Association, which support most of the general-interest computing desires of the campus. As such, the XCF stands as a focus for a small group of computer-scientists uniquely interested in computer science.
|
||||
Members of the organization have been involved in projects such as NNTP, GTK, GIMP, Gnutella, and Viola. Members of the XCF were instrumental in defending against the Morris Internet worm.
|
||||
|
||||
|
||||
== Notable alumni ==
|
||||
Notable alumni of the organization include:
|
||||
Jonathan Blow, Gene Kan, Spencer Kimball, Peter Mattis, Pei-Yuan Wei, and Phil Lapsley.
|
||||
|
||||
|
||||
== References ==
|
||||
|
||||
|
||||
== External links ==
|
||||
Official website
|
||||
"Student Organization Website".
|
||||
"Older XCF website". eXperimental Computing Facility, University of California at Berkeley. Archived from the original on 27 October 2010. Retrieved 29 March 2015.
|
||||
@ -0,0 +1,24 @@
|
||||
---
|
||||
title: "Exclusive relationship (programming)"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Exclusive_relationship_(programming)"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:33:37.099079+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
In computing, an exclusive relationship is a type of Relationship in computer data base design.
|
||||
In Relational Database Design, in some cases the existence of one kind of relationship type precludes the existence of another. Entities within an entity type A may be related by a relationship type R to an entity in entity type B or entity type C but not both. The relationship types are said to be mutually exclusive. Usually, both relationship types will have the same name.
|
||||
|
||||
|
||||
== Example ==
|
||||
A Data (Entity A) could be Sent (Relationship Name) to a Monitor (Entity B) or a Printer (Entity C) to be shown. In this case, the relationship between the Monitor and Printer at one side and Data at the other side is an Exclusive Relationship. Of course it is assumed that Data could be sent to only one of the targets at a time, not to both.
|
||||
|
||||
--- Sent_To ---> Monitor
|
||||
Data
|
||||
--- Sent_To ---> Printer
|
||||
|
||||
|
||||
== References ==
|
||||
Jan L. Harrington, Relational Database Design Clearly Explained, Morgan Kaufmann, 2002, ISBN 1-55860-820-6, pages 354-355
|
||||
@ -4,7 +4,7 @@ chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Experimental_software_engineering"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T09:56:54.579784+00:00"
|
||||
date_saved: "2026-05-05T11:33:39.536670+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
|
||||
29
data/en.wikipedia.org/wiki/Explicit_parallelism-0.md
Normal file
29
data/en.wikipedia.org/wiki/Explicit_parallelism-0.md
Normal file
@ -0,0 +1,29 @@
|
||||
---
|
||||
title: "Explicit parallelism"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Explicit_parallelism"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:33:40.712739+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
In computer programming, explicit parallelism is the representation of concurrent computations using primitives in the form of operators, function calls or special-purpose directives. Most parallel primitives are related to process synchronization, communication and process partitioning. As they rarely contribute to actually carry out the intended computation of the program but, rather, structure it, their computational cost is often considered as overhead.
|
||||
The advantage of explicit parallel programming is increased programmer control over the computation. A skilled parallel programmer may take advantage of explicit parallelism to produce efficient code for a given target computation environment. However, programming with explicit parallelism is often difficult, especially for non-computing specialists, because of the extra work and skill involved in developing it.
|
||||
In some instances, explicit parallelism may be avoided with the use of an optimizing compiler or runtime that automatically deduces the parallelism inherent to computations, known as implicit parallelism.
|
||||
|
||||
|
||||
== Programming languages that support explicit parallelism ==
|
||||
Some of the programming languages that support explicit parallelism are:
|
||||
|
||||
Ada
|
||||
Ease
|
||||
Erlang
|
||||
Java
|
||||
JavaSpaces
|
||||
Message Passing Interface
|
||||
Occam
|
||||
Parallel Virtual Machine
|
||||
|
||||
|
||||
== References ==
|
||||
19
data/en.wikipedia.org/wiki/Expression_language-0.md
Normal file
19
data/en.wikipedia.org/wiki/Expression_language-0.md
Normal file
@ -0,0 +1,19 @@
|
||||
---
|
||||
title: "Expression language"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Expression_language"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:33:41.950081+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
An expression language is a computer language for creating a machine readable representation of specific domain knowledge. Examples include:
|
||||
|
||||
Advanced Boolean Expression Language, an obsolete hardware description language for hardware descriptions
|
||||
Data Analysis Expressions (DAX), an expression language developed by Microsoft and used in Power Pivot, among other places
|
||||
Jakarta Expression Language, a domain-specific language used in Jakarta EE web applications. Formerly known as "Unified Expression Language", "Expression Language" or just "the Expression Language").
|
||||
Rights Expression Languages, machine processable language used for representing immaterial rights such as copyright and license information
|
||||
|
||||
|
||||
== References ==
|
||||
@ -0,0 +1,23 @@
|
||||
---
|
||||
title: "Extended Semantic Web Conference"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Extended_Semantic_Web_Conference"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:33:43.166140+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
The Extended Semantic Web Conference (abbreviated as ESWC), formerly known as the European Semantic Web Conference, is a yearly international academic conference on the topic of the Semantic Web. The event began in 2004, as the European Semantic Web Symposium. The goal of the event is "to bring together researchers and practitioners dealing with different aspects of semantics on the Web".
|
||||
Topics covered at the conference include linked data, machine learning, natural language processing and information retrieval, ontologies, reasoning, semantic data management, services, processes, and cloud computing, social Web and Web science, in-use and industrial, digital libraries and cultural heritage, and e-government.
|
||||
|
||||
|
||||
== List of conferences ==
|
||||
Past and future ESWC conferences include:
|
||||
|
||||
|
||||
== References ==
|
||||
|
||||
|
||||
== External links ==
|
||||
ESWC website
|
||||
20
data/en.wikipedia.org/wiki/FBus-0.md
Normal file
20
data/en.wikipedia.org/wiki/FBus-0.md
Normal file
@ -0,0 +1,20 @@
|
||||
---
|
||||
title: "FBus"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/FBus"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:33:45.542496+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
Fbus (for "Fast Bus") is an ANSI/IEEE data bus protocol oriented towards backplanes and cell phones. The standard specifies a way for various pieces of electronic hardware to communicate, typically with one piece acting as master (sending a request), and another acting as a slave (returning an answer). The FBus is a bi-directional full-duplex serial type bus running at 115,200 bit/s, 8 data bits, no parity, one stop bit (8N1). Much like a standard RS-232 serial port, FBus connections use one pin for data transmit, one pin for data receive and one pin for ground.
|
||||
The Fast Bus standard specifies completely the size, power requirements, signalling levels, and communications protocols for boards that live in a Fast Bus crate, which is also a part of the specification.
|
||||
Fbus was developed by Nokia as an improved replacement of the Mbus, which is only half-duplex and transfers at a slower speed of 9600 bit/s.
|
||||
|
||||
|
||||
== Interfacing with a cell phone ==
|
||||
The Fast Bus connection on a cell phone can be interfaced with an RS-232 serial port by building a custom cable.
|
||||
|
||||
|
||||
== References ==
|
||||
24
data/en.wikipedia.org/wiki/FINO-0.md
Normal file
24
data/en.wikipedia.org/wiki/FINO-0.md
Normal file
@ -0,0 +1,24 @@
|
||||
---
|
||||
title: "FINO"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/FINO"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:33:46.722603+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
In computer science, FINO is a humorous scheduling algorithm. It is an acronym for first in, never out as opposed to traditional first in, first out (FIFO) and last in, first out (LIFO) algorithms. A similar acronym is "FISH", for first in, still here.
|
||||
FINO works by withholding all scheduled tasks permanently. No matter how many tasks are scheduled at any time, no task ever actually takes place.
|
||||
A stateful FINO queue can be used to implement a memory leak.
|
||||
The first mention of FINO appears in the Signetics 25120 write-only memory joke datasheet.
|
||||
|
||||
|
||||
== See also ==
|
||||
Bit bucket
|
||||
Black hole (networking)
|
||||
/dev/null
|
||||
Write-only memory
|
||||
|
||||
|
||||
== References ==
|
||||
39
data/en.wikipedia.org/wiki/FIXP-0.md
Normal file
39
data/en.wikipedia.org/wiki/FIXP-0.md
Normal file
@ -0,0 +1,39 @@
|
||||
---
|
||||
title: "FIXP"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/FIXP"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:33:51.499406+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
In computer science, FIXP is a complexity class introduced by Kousha Etessami and Mihalis Yannakakis at 2010. It represents problems that can be solved by computing a fixed point of a function that satisfies the conditions of Brouwer's fixed point theorem. More formally, FIXP contains search problems that can be cast as fixed point computation problems for functions represented by algebraic circuits over basis {+,*,-,/,max,min} with rational constants.
|
||||
They prove that some fundamental problems in economics and game theory are complete for FIXP, in particular:
|
||||
|
||||
Nash equilibrium computation - computing an exact or approximate mixed-strategy Nash equilibrium in a game with three or more players.
|
||||
Market equilibrium computation - computing competitive-equilibrium prices for exchange economies with algebraic demand functions.
|
||||
|
||||
|
||||
== Proving membership in FIXP ==
|
||||
Filos-Ratsikas, Hansen, Høgh and Hollender present a general method for proving membership in FIXP. Their method constructs a black-box that they call “OPT-gate”, which can solve most convex optimization problems. Using their technique, they prove FIXP membership of:
|
||||
|
||||
Market equilibrium computation in Arrow-Debreu markets with general concave utilities;
|
||||
Computing an envy-free cake cutting with very general valuations is FIXP-complete.
|
||||
They also prove FIXP membership for Nash equilibrium computation and for the mechanism of Hylland and Zeckhauser for fair random assignment.
|
||||
|
||||
|
||||
== Relations to other classes ==
|
||||
|
||||
|
||||
=== Relation to PPAD ===
|
||||
Etessami and Yannakakis describe the relation succinctly by saying that "The piecewise-linear fragment of FIXP equals PPAD". In other words, the problems in PPAD are the problems in FIXP in which the input function is piecewise-linear.
|
||||
Solutions to problems in PPAD are rational numbers, whereas solutions to problems in FIXP are algebraic numbers.
|
||||
PPAD is contained in function classes that are in the intersection of NP and co-NP, whereas FIXP is conjectured to be much harder, and lie in the "harder" end of PSPACE.
|
||||
|
||||
|
||||
=== Relation to SRS ===
|
||||
Computing an approximate Nash equilibrium to any factor smaller than 1/2 is at least as hard as the square-root sum problem.
|
||||
|
||||
|
||||
== References ==
|
||||
@ -0,0 +1,16 @@
|
||||
---
|
||||
title: "Factory Interface Network Service"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Factory_Interface_Network_Service"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:33:47.911853+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
FINS, Factory Interface Network Service, is a network protocol used by Omron PLCs, over different physical networks like Ethernet, Controller Link, DeviceNet and RS-232C.
|
||||
The FINS communications service was developed by Omron to provide a consistent way for PLCs and computers on various networks to communicate. Compatible network types include Ethernet, Host Link, Controller Link, SYSMAC LINK, SYSMAC WAY, and Toolbus. FINS allows communications between nodes up to three network levels. A direct connection between a computer and a PLC via Host Link is not considered a network level.
|
||||
|
||||
|
||||
== References ==
|
||||
Omron FINS Ethernet
|
||||
24
data/en.wikipedia.org/wiki/Fast_path-0.md
Normal file
24
data/en.wikipedia.org/wiki/Fast_path-0.md
Normal file
@ -0,0 +1,24 @@
|
||||
---
|
||||
title: "Fast path"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Fast_path"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:33:44.353521+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
Fast path is a term used in computer science to describe a path with shorter instruction path length through a program compared to the normal path. For a fast path to be effective it must handle the most commonly occurring tasks more efficiently than the normal path, leaving the latter to handle uncommon cases, corner cases, error handling, and other anomalies. Fast paths are a form of optimization.
|
||||
For example dedicated packet routing hardware used to build computer networks will often take care of the most common kinds of packets in hardware, with other kinds passed to the "slow path", usually implemented by software running on the control processor. For example, packets with special control information, packets with errors, or packets directed at the device itself instead of being routed elsewhere would be passed to the slow path. The slow path is more flexible, and can handle any kind of packet.
|
||||
Even in pure software, specific implementations have been developed that leverage the concept of a fast path to maximize the performance of packet processing. In these implementations, the networking stack is split into two layers and the lower layer processes the majority of incoming packets outside the operating system (OS) environment without incurring any of the OS overheads that degrade overall performance. Only those rare packets that require complex processing are forwarded to the OS networking stack, which performs the necessary management, signaling and control functions.
|
||||
Some hardware RAID controllers implement a "fast path" for write-through access which bypasses the controller's cache in certain situations. This tends to increase IOPS, particularly for solid-state drives.
|
||||
For a fast path to be beneficial, it must process the majority of operations. This is because the "fast path or slow path" test itself slows down the slow path. One common way to perform a denial-of-service attack is to flood a device with packets which require use of the slow path.
|
||||
|
||||
|
||||
== See also ==
|
||||
Control plane
|
||||
Data plane
|
||||
Self-modifying code
|
||||
|
||||
|
||||
== References ==
|
||||
29
data/en.wikipedia.org/wiki/First-class_message-0.md
Normal file
29
data/en.wikipedia.org/wiki/First-class_message-0.md
Normal file
@ -0,0 +1,29 @@
|
||||
---
|
||||
title: "First-class message"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/First-class_message"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:33:49.088591+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
In object-oriented programming, a programming language is said to have first-class messages or dynamic messages if in a method call not only the receiving object and parameter list can be varied dynamically (i.e. bound to a variable or computed as an expression) but also the specific method invoked.
|
||||
Typed object-oriented programming languages, such as Java and C++, often do not support first-class methods. Smalltalk only support them in an untyped way. In Objective-C (Cocoa), you can use NSInvocation to represent first-class messages in a way that is aware of the types at runtime; however, safe use still relies on the programmer.
|
||||
Some theoretical progress has been made to support first-class messages in a type-safe manner, but none of the proposed systems has been implemented in a programming language, possibly due to their complexity.
|
||||
|
||||
|
||||
== See also ==
|
||||
Delegate (object-oriented programming)
|
||||
First-class function
|
||||
|
||||
|
||||
== Notes ==
|
||||
|
||||
|
||||
== References ==
|
||||
Susumu Nishimura (1998). "Static Typing for Dynamic Messages". POPL '98.
|
||||
Michelle Bugliesi & Silvia Crafa (1999). "Object Calculi for Dynamic Messages". FOOL 6.
|
||||
Martin Müller & Susumu Nishimura (2000). "Type Inference for First-Class Messages with Feature Constraints". International Journal of Foundations of Computer Science 11:1.
|
||||
François Pottier (2000). "A versatile Constraint-based Type Inference System". Nordic Journal of Computing.
|
||||
Paritosh Shroff & Scott F. Smith. "Type Inference for First-Class Messages with Match-Functions".
|
||||
@ -0,0 +1,13 @@
|
||||
---
|
||||
title: "Fixed-priority pre-emptive scheduling"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Fixed-priority_pre-emptive_scheduling"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:33:50.314265+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
Fixed-priority preemptive scheduling is a scheduling system commonly used in real-time systems. With fixed priority preemptive scheduling, the scheduler ensures that at any given time, the processor executes the highest priority task of all those tasks that are currently ready to execute.
|
||||
The preemptive scheduler has a clock interrupt task that can provide the scheduler with options to switch after the task has had a given period to execute—the time slice. This scheduling system has the advantage of making sure no task hogs the processor for any time longer than the time slice. However, this scheduling scheme is vulnerable to process or thread lockout: since priority is given to higher-priority tasks, the lower-priority tasks could wait an indefinite amount of time. One common method of arbitrating this situation is aging, which gradually increments the priority of waiting processes and threads, ensuring that they will all eventually execute. Most real-time operating systems (RTOSs) have preemptive schedulers. Also turning off time slicing effectively gives you the non-preemptive RTOS.
|
||||
Preemptive scheduling is often differentiated with cooperative scheduling, in which a task can run continuously from start to end without being preempted by other tasks. To have a task switch, the task must explicitly call the scheduler. Cooperative scheduling is used in a few RTOS such as Salvo or TinyOS.
|
||||
27
data/en.wikipedia.org/wiki/Flag_(programming)-0.md
Normal file
27
data/en.wikipedia.org/wiki/Flag_(programming)-0.md
Normal file
@ -0,0 +1,27 @@
|
||||
---
|
||||
title: "Flag (programming)"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Flag_(programming)"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:33:52.662586+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
In computer programming, a flag can refer to one or more bits that are used to store a binary value or a Boolean variable for signaling special code conditions, such as file empty or full queue statuses.
|
||||
Flags may be found as members of a defined data structure, such as a database record, and the meaning of the value contained in a flag will generally be defined in relation to the data structure it is part of. In many cases, the binary value of a flag will be understood to represent one of several possible states or statuses. In other cases, the binary values may represent one or more attributes in a bit field, often related to abilities or permissions, such as "can be written to" or "can be deleted". However, there are many other possible meanings that can be assigned to flag values. One common use of flags is to mark or designate data structures for future processing.
|
||||
Within microprocessors and other logic devices, flags are commonly used to control or indicate the intermediate or final state or outcome of different operations. Microprocessors typically have, for example, a status register that is composed of such flags, and the flags are used to indicate various post-operation conditions, such as when there has been an arithmetic overflow. The flags can be utilized in subsequent operations, such as in processing conditional jump instructions. For example a je (Jump if Equal) instruction in the x86 assembly language will result in a jump if the Z (zero) flag was set by some previous operation.
|
||||
A command line switch is also referred to as a "flag". Command line programs often start with an option parser that translates command line switches into flags in the sense of this article.
|
||||
|
||||
|
||||
== See also ==
|
||||
Bit field
|
||||
Control register
|
||||
Enumerated type
|
||||
FLAGS register (computing)
|
||||
Program status word
|
||||
Semaphore (programming)
|
||||
Status register
|
||||
|
||||
|
||||
== References ==
|
||||
34
data/en.wikipedia.org/wiki/Flag_day_(computing)-0.md
Normal file
34
data/en.wikipedia.org/wiki/Flag_day_(computing)-0.md
Normal file
@ -0,0 +1,34 @@
|
||||
---
|
||||
title: "Flag day (computing)"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Flag_day_(computing)"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:33:54.003638+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
A flag day (or flag day cutover) in computing and system administration is a planned change that requires many systems to be upgraded or converted in a coordinated way because the old and new versions are not mutually compatible. Such changes are typically costly to carry out and, if problems arise, difficult to roll back.
|
||||
Flag days can occur when constraints on backward compatibility or forward compatibility prevent a gradual migration, requiring updates to be performed nearly simultaneously for the overall system to function. In contrast, phased deployments aim to preserve service continuity by allowing old and new versions to coexist during the transition.
|
||||
|
||||
|
||||
== Origin ==
|
||||
The term is commonly traced to the Multics project: a system-wide change to the system's handling of the ASCII character set was scheduled for the U.S. holiday Flag Day (14 June 1966), and the name was applied by analogy to other coordinated, incompatible changeovers.
|
||||
|
||||
|
||||
== Examples ==
|
||||
On 1 January 1983, the ARPANET conducted a coordinated transition from NCP to the TCP/IP protocol suite, a milestone sometimes described as a network “flag day”.
|
||||
"DNS Flag Day 2019" was a coordinated change beginning on 1 February 2019, in which DNS software and service providers removed certain workarounds related to EDNS handling, potentially affecting name resolution for domains hosted on non-compliant authoritative servers.
|
||||
|
||||
|
||||
== See also ==
|
||||
Backward compatibility
|
||||
Forward compatibility
|
||||
Protocol ossification
|
||||
|
||||
|
||||
== References ==
|
||||
|
||||
|
||||
== External links ==
|
||||
DNS Flag Day 2019
|
||||
20
data/en.wikipedia.org/wiki/Flat_neighborhood_network-0.md
Normal file
20
data/en.wikipedia.org/wiki/Flat_neighborhood_network-0.md
Normal file
@ -0,0 +1,20 @@
|
||||
---
|
||||
title: "Flat neighborhood network"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Flat_neighborhood_network"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:33:55.201010+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
Flat Neighborhood Network (FNN) is a topology for distributed computing and other computer networks. Each node connects to two or more switches which, ideally, entirely cover the node collection, so that each node can connect to any other node in two "hops" (jump up to one switch and down to the other node). This contrasts to topologies with fewer cables per node which communicate with remote nodes via intermediate nodes, as in Hypercube (see The Connection Machine).
|
||||
|
||||
|
||||
== See also ==
|
||||
Thinking Machines Corporation built the Connection Machine employing hypercube topology for its compute nodes.
|
||||
Kentucky's Linux/Athlon Testbed KLAT2 is an archetypal implementation.
|
||||
|
||||
|
||||
== External links ==
|
||||
The Aggregate (at the University of Kentucky) defines FNN and includes a bibliography.
|
||||
33
data/en.wikipedia.org/wiki/Focus-plus-context_screen-0.md
Normal file
33
data/en.wikipedia.org/wiki/Focus-plus-context_screen-0.md
Normal file
@ -0,0 +1,33 @@
|
||||
---
|
||||
title: "Focus-plus-context screen"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Focus-plus-context_screen"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:33:56.395190+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
A focus-plus-context screen is a specialized type of display device that consists of one or more high-resolution "focus" displays embedded into a larger low-resolution "context" display. Image content is displayed across all display regions, such that the scaling of the image is preserved, while its resolution varies across the display regions.
|
||||
The original focus-plus-context screen prototype consisted of an 18"/45 cm LCD screen embedded in a 5'/150 cm front-projected screen. Alternative designs have been proposed that achieve the mixed-resolution effect by combining two or more projectors with different focal lengths
|
||||
While the high-resolution area of the original prototype was located at a fixed location, follow-up projects have obtained a movable focus area by using a Tablet PC.
|
||||
Patrick Baudisch is the inventor of focus-plus-context screens (2000, while at Xerox PARC)
|
||||
|
||||
|
||||
== Advantages ==
|
||||
Allows users to leverage their foveal and their peripheral vision
|
||||
Cheaper to manufacture than a display that is high-resolution across the entire display surface
|
||||
Displays entirety and details of large images in a single view. Unlike approaches that combine entirety and details in software (fisheye views), focus-plus-context screens do not introduce distortion.
|
||||
|
||||
|
||||
== Disadvantages ==
|
||||
In existing implementations, the focus display is either fixed or moving it is physically demanding
|
||||
|
||||
|
||||
== References ==
|
||||
|
||||
Notes
|
||||
|
||||
|
||||
== External links ==
|
||||
Focus-plus-context screens homepage
|
||||
111
data/en.wikipedia.org/wiki/Formula_game-0.md
Normal file
111
data/en.wikipedia.org/wiki/Formula_game-0.md
Normal file
@ -0,0 +1,111 @@
|
||||
---
|
||||
title: "Formula game"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Formula_game"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:33:57.616949+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
A formula game is an artificial game represented by a fully quantified Boolean formula such as
|
||||
|
||||
|
||||
|
||||
∃
|
||||
|
||||
x
|
||||
|
||||
1
|
||||
|
||||
|
||||
∀
|
||||
|
||||
x
|
||||
|
||||
2
|
||||
|
||||
|
||||
∃
|
||||
|
||||
x
|
||||
|
||||
3
|
||||
|
||||
|
||||
…
|
||||
ψ
|
||||
|
||||
|
||||
{\displaystyle \exists x_{1}\forall x_{2}\exists x_{3}\ldots \psi }
|
||||
|
||||
.
|
||||
One player (E) has the goal of choosing values so as to make the formula
|
||||
|
||||
|
||||
|
||||
ψ
|
||||
|
||||
|
||||
{\displaystyle \psi }
|
||||
|
||||
true, and selects values for the variables that are existentially quantified with
|
||||
|
||||
|
||||
|
||||
∃
|
||||
|
||||
|
||||
{\displaystyle \exists }
|
||||
|
||||
. The opposing player (A) has the goal of making the formula
|
||||
|
||||
|
||||
|
||||
ψ
|
||||
|
||||
|
||||
{\displaystyle \psi }
|
||||
|
||||
false, and selects values for the variables that are universally quantified with
|
||||
|
||||
|
||||
|
||||
∀
|
||||
|
||||
|
||||
{\displaystyle \forall }
|
||||
|
||||
. The players take turns according to the order of the quantifiers, each assigning a value to the next bound variable in the original formula. Once all variables have been assigned values, Player E wins if the resulting expression is true.
|
||||
In computational complexity theory, the language FORMULA-GAME is defined as all formulas
|
||||
|
||||
|
||||
|
||||
Φ
|
||||
|
||||
|
||||
{\displaystyle \Phi }
|
||||
|
||||
such that Player E has a winning strategy in the game represented by
|
||||
|
||||
|
||||
|
||||
Φ
|
||||
|
||||
|
||||
{\displaystyle \Phi }
|
||||
|
||||
. FORMULA-GAME is PSPACE-complete because it is exactly the same decision problem as True quantified Boolean formula. Player E has a winning strategy exactly when every choice they must make in a game has a truth assignment that makes
|
||||
|
||||
|
||||
|
||||
ψ
|
||||
|
||||
|
||||
{\displaystyle \psi }
|
||||
|
||||
true, no matter what choice Player A makes.
|
||||
|
||||
|
||||
== References ==
|
||||
Sipser, Michael. (2006). Introduction to the Theory of Computation. Boston: Thomson Course Technology.
|
||||
@ -4,7 +4,7 @@ chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/FreeHAL"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T10:11:26.504428+00:00"
|
||||
date_saved: "2026-05-05T11:33:58.884966+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
|
||||
22
data/en.wikipedia.org/wiki/GLOH-0.md
Normal file
22
data/en.wikipedia.org/wiki/GLOH-0.md
Normal file
@ -0,0 +1,22 @@
|
||||
---
|
||||
title: "GLOH"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/GLOH"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:11.977738+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
GLOH (Gradient Location and Orientation Histogram) is a robust image descriptor that can be used in computer vision tasks. It is a SIFT-like descriptor that considers more spatial regions for the histograms. An intermediate vector is computed from 17 location and 16 orientation bins, for a total of 272-dimensions. Principal components analysis (PCA) is then used to reduce the vector size to 128 (same size as SIFT descriptor vector).
|
||||
|
||||
|
||||
== See also ==
|
||||
Scale-invariant feature transform
|
||||
Speeded Up Robust Features
|
||||
LESH – Local Energy-based Shape Histogram
|
||||
Feature detection (computer vision)
|
||||
|
||||
|
||||
== References ==
|
||||
Krystian Mikolajczyk and Cordelia Schmid "A performance evaluation of local descriptors", IEEE Transactions on Pattern Analysis and Machine Intelligence, 10, 27, pp 1615--1630, 2005.
|
||||
14
data/en.wikipedia.org/wiki/Gabbay's_separation_theorem-0.md
Normal file
14
data/en.wikipedia.org/wiki/Gabbay's_separation_theorem-0.md
Normal file
@ -0,0 +1,14 @@
|
||||
---
|
||||
title: "Gabbay's separation theorem"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Gabbay's_separation_theorem"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:00.061844+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
In mathematical logic and computer science, Gabbay's separation theorem, named after Dov Gabbay, states that any arbitrary temporal logic formula can be rewritten in a logically equivalent "past → future" form. I.e. the future becomes what must be satisfied. This form can be used as execution rules; a MetateM program is a set of such rules.
|
||||
|
||||
|
||||
== References ==
|
||||
17
data/en.wikipedia.org/wiki/Gateway_Setup_Assistant-0.md
Normal file
17
data/en.wikipedia.org/wiki/Gateway_Setup_Assistant-0.md
Normal file
@ -0,0 +1,17 @@
|
||||
---
|
||||
title: "Gateway Setup Assistant"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Gateway_Setup_Assistant"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:01.204024+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
Gateway Setup Assistant is a tool in Apple Computer's Mac OS X Server versions 10.4 and higher that guides users through setting up Mac OS X Server as an internet gateway.
|
||||
The Gateway Setup Assistant assumes two network interfaces and will automatically configure the DHCP, NAT, firewall, DNS, and VPN services.
|
||||
|
||||
|
||||
== External links ==
|
||||
Apple Product page
|
||||
Apple documentation PDF
|
||||
35
data/en.wikipedia.org/wiki/Gem5-0.md
Normal file
35
data/en.wikipedia.org/wiki/Gem5-0.md
Normal file
@ -0,0 +1,35 @@
|
||||
---
|
||||
title: "Gem5"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Gem5"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:02.399109+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
The gem5 simulator is an open source discrete-event computer architecture simulator. It combines system-level and microarchitectural simulation, allowing users to analyze and test a multiplicity of hardware configurations, architectures, and software environments, without access or development of any hardware.
|
||||
The simulator is capable of simulating modern operating system running on a simulator system and supports a variety of instruction set architectures (ISAs), including x86, ARM, RISC-V. gem5 comes with a library of pre-made components that conform to a modular design methodology allowing researchers to conduct experiments on a wide systems with relative ease. As such gem5 is used to in research tasks as diverse as processor design, the development of memory subsystems, and application performance optimization. In addition to research, gem5 serves as an important education tool, enabling educators to demonstrate to the impact computer architecture design decisions can have on computer system performance.
|
||||
|
||||
|
||||
== History ==
|
||||
The gem5 simulator was born out of the merger of m5 (a detailed CPU simulator) and GEMS simulator (a detailed memory system simulator) in 2011.
|
||||
|
||||
|
||||
== Features and capabilities ==
|
||||
Multi-level simulation: gem5 supports both system-level and detailed microarchitectural simulation.
|
||||
Flexible processor and system modeling: gem5 can model a wide range of processor architectures, including x86, ARM, RISC-V, SPARC, and MIPS.
|
||||
Configurable memory hierarchies: gem5 allows users to define custom cache and memory configurations for exploring different system setups.
|
||||
Support for full-system and syscall emulation: gem5 enables simulation of full-system software stacks, including OS and application code, or simplified syscall emulation for faster performance.
|
||||
Modular design: gem5 is highly modular, enabling researchers to plug in different models for CPUs, caches, interconnects, and other system components.
|
||||
Extensive library of models: gem5 includes detailed models for CPUs (timing, atomic, in-order, and out-of-order), memory, interconnects, and peripheral devices.
|
||||
Scalable multi-core simulation: gem5 supports single-core to complex multicore and multi-threaded architectures.
|
||||
Scripting and automation with Python: gem5 allows users to configure and control simulations using Python scripts, facilitating complex experiment setups via Python.
|
||||
|
||||
|
||||
== References ==
|
||||
|
||||
|
||||
== External links ==
|
||||
Official website
|
||||
The gem5 source repository on GitHub
|
||||
23
data/en.wikipedia.org/wiki/General-purpose_language-0.md
Normal file
23
data/en.wikipedia.org/wiki/General-purpose_language-0.md
Normal file
@ -0,0 +1,23 @@
|
||||
---
|
||||
title: "General-purpose language"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/General-purpose_language"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:03.593912+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
A general-purpose language (GPL) is a computer language that is broadly applicable across application domains, and lacks specialized features for a particular domain. This is in contrast to a domain-specific language (DSL), which is specialized to a particular application domain. The line is not always sharp, as a language may have specialized features for a particular domain but be applicable more broadly, or conversely may in principle be capable of broad application but in practice used primarily for a specific domain.
|
||||
General-purpose languages are further subdivided by the kind of language, and include:
|
||||
|
||||
General-purpose markup languages, such as XML
|
||||
General-purpose modeling language such as the Unified Modeling Language (UML)
|
||||
General-purpose programming languages, such as C, Java, PHP, or Python
|
||||
|
||||
|
||||
== References ==
|
||||
|
||||
|
||||
== External links ==
|
||||
Hicks, Mike; Levin, Dave. "CMSC 330: Organization of Programming Languages" (PDF). cs.umd.edu. Retrieved April 6, 2020.
|
||||
25
data/en.wikipedia.org/wiki/General-purpose_modeling-0.md
Normal file
25
data/en.wikipedia.org/wiki/General-purpose_modeling-0.md
Normal file
@ -0,0 +1,25 @@
|
||||
---
|
||||
title: "General-purpose modeling"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/General-purpose_modeling"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:04.776782+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
General-purpose modeling (GPM) is the systematic use of a general-purpose modeling language to represent the various facets of an object or a system. Examples of GPM languages are:
|
||||
|
||||
The Unified Modeling Language (UML), an industry standard for modeling software-intensive systems
|
||||
EXPRESS, a data modeling language for product data, standardized as ISO 10303-11
|
||||
IDEF, a group of languages from the 1970s that aimed to be neutral, generic and reusable
|
||||
Gellish, an industry standard natural language oriented modeling language for storage and exchange of data and knowledge, published in 2005
|
||||
XML, a data modeling language now beginning to be used to model code (MetaL, Microsoft .Net [1])
|
||||
GPM languages are in contrast with domain-specific modeling languages (DSMs).
|
||||
|
||||
|
||||
== See also ==
|
||||
Model-driven engineering (MDE)
|
||||
|
||||
|
||||
== References ==
|
||||
19
data/en.wikipedia.org/wiki/Generation_gap_(pattern)-0.md
Normal file
19
data/en.wikipedia.org/wiki/Generation_gap_(pattern)-0.md
Normal file
@ -0,0 +1,19 @@
|
||||
---
|
||||
title: "Generation gap (pattern)"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Generation_gap_(pattern)"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:05.887524+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
Generation gap is a software design pattern documented by John Vlissides that treats automatically generated code differently than code that was written by a developer. Modifications should not be made to generated code, as they would be overwritten if the code generation process was ever re-run, such as during recompilation. Vlissides proposed creating a subclass of the generated code which contains the desired modification. This might be considered an example of the template method pattern.
|
||||
|
||||
|
||||
== Modern languages ==
|
||||
Modern byte-code language like Java were in their early stages when Vlissides developed his ideas. In a language like C# or Java, this pattern may be followed by generating an interface, which is a completely abstract class. The developer would then hand-modify a concrete implementation of the generated interface.
|
||||
C# have support for partial classes which is a class whose definition may be split into multiple pieces, within a single source-code file or across multiple files.
|
||||
|
||||
|
||||
== References ==
|
||||
@ -0,0 +1,14 @@
|
||||
---
|
||||
title: "Genetic memory (computer science)"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Genetic_memory_(computer_science)"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:07.084593+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
In computer science, genetic memory refers to an artificial neural network combination of genetic algorithm and the mathematical model of sparse distributed memory. It can be used to predict weather patterns. Genetic memory and genetic algorithms have also gained an interest in the creation of artificial life.
|
||||
|
||||
|
||||
== References ==
|
||||
23
data/en.wikipedia.org/wiki/Genome_informatics-0.md
Normal file
23
data/en.wikipedia.org/wiki/Genome_informatics-0.md
Normal file
@ -0,0 +1,23 @@
|
||||
---
|
||||
title: "Genome informatics"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Genome_informatics"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:08.302426+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
|
||||
== Introduction ==
|
||||
Genome informatics is a subfield of bioinformatics that uses computational tools to process and analyze genomic information through databases, algorithms, and bioinformatics applications. Genome informatics includes methods for analyzing DNA sequence data, predicting protein sequences and structures, and studying genomic datasets using genomic tools and technologies. These methods help in the analysis of complex traits, precision medicine, and research in evolutionary biology.
|
||||
|
||||
|
||||
== Genomic Tools and Technologies ==
|
||||
|
||||
|
||||
== Precision Medicine ==
|
||||
By using sequencing and computational analysis, genetic sequences can be examined to locate mutations that influence disease. Genetic variants are located and analyzed to help researchers figure out whether the variant is associated with a disease. By using this process, researchers can differentiate between common and harmful variants. This information is then used in precision medicine to determine disease risk and design treatments specifically for each person. Genome informatics is commonly used in oncology to identify tumor-specific mutations and develop targeted treatments. Advances in sequencing technology result in advances in medicine, which is why research in genome informatics is essential.
|
||||
|
||||
|
||||
== References ==
|
||||
28
data/en.wikipedia.org/wiki/Given-When-Then-0.md
Normal file
28
data/en.wikipedia.org/wiki/Given-When-Then-0.md
Normal file
@ -0,0 +1,28 @@
|
||||
---
|
||||
title: "Given-When-Then"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Given-When-Then"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:09.519028+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
Given-When-Then (GWT) is a semi-structured way to write down test cases. They can either be tested manually or automated as browser tests with tools like Selenium and Cucumber.
|
||||
It derives its name from the three clauses used, which start with the words given, when and then. Given describes the preconditions and initial state before the start of a test and allows for any pre-test setup that may occur. When describes actions taken by a user during a test. Then describes the outcome resulting from actions taken in the when clause.
|
||||
The Given-When-Then was proposed by Dan North in 2006, as part of behavior-driven development.
|
||||
|
||||
|
||||
== Example ==
|
||||
A Given-When-Then test case for a hypothetical inventory software could be structured as follows:
|
||||
|
||||
|
||||
== See also ==
|
||||
Acceptance test-driven development
|
||||
Acceptance testing
|
||||
Behavior-driven development
|
||||
Cucumber syntax
|
||||
Hoare triple
|
||||
|
||||
|
||||
== References ==
|
||||
@ -4,7 +4,7 @@ chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Global_Neighborhood_Watch"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T08:58:18.808348+00:00"
|
||||
date_saved: "2026-05-05T11:34:10.760647+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
|
||||
23
data/en.wikipedia.org/wiki/Graph-structured_stack-0.md
Normal file
23
data/en.wikipedia.org/wiki/Graph-structured_stack-0.md
Normal file
@ -0,0 +1,23 @@
|
||||
---
|
||||
title: "Graph-structured stack"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Graph-structured_stack"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:14.314593+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
In computer science, a graph-structured stack (GSS) is a directed acyclic graph where each directed path represents a stack.
|
||||
The graph-structured stack is an essential part of Tomita's algorithm, where it replaces the usual stack of a pushdown automaton. This allows the algorithm to encode the nondeterministic choices in parsing an ambiguous grammar, sometimes with greater efficiency.
|
||||
In the following diagram, there are four stacks: {7,3,1,0}, {7,4,1,0}, {7,5,2,0}, and {8,6,2,0}.
|
||||
|
||||
Another way to simulate nondeterminism would be to duplicate the stack as needed. The duplication would be less efficient since vertices would not be shared. For this example, 16 vertices would be needed instead of 9.
|
||||
|
||||
|
||||
== Operations ==
|
||||
|
||||
|
||||
== References ==
|
||||
Masaru Tomita. Graph-Structured Stack And Natural Language Parsing. Annual Meeting of the Association of Computational Linguistics, 1988. [1]
|
||||
Elizabeth Scott, Adrian Johnstone GLL Parsing gll.pdf
|
||||
23
data/en.wikipedia.org/wiki/Graph_matching-0.md
Normal file
23
data/en.wikipedia.org/wiki/Graph_matching-0.md
Normal file
@ -0,0 +1,23 @@
|
||||
---
|
||||
title: "Graph matching"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Graph_matching"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:13.163884+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
Graph matching is the problem of finding a similarity between graphs.
|
||||
Graphs are commonly used to encode structural information in many fields, including computer vision and pattern recognition, and graph matching is an important tool in these areas. In these areas it is commonly assumed that the comparison is between the data graph and the model graph.
|
||||
The case of exact graph matching is known as the graph isomorphism problem. The problem of exact matching of a graph to a part of another graph is called subgraph isomorphism problem.
|
||||
Inexact graph matching refers to matching problems when exact matching is impossible, e.g., when the number of vertices in the two graphs are different. In this case it is required to find the best possible match. For example, in image recognition applications, the results of image segmentation in image processing typically produces data graphs with the numbers of vertices much larger than in the model graphs data expected to match against. In the case of attributed graphs, even if the numbers of vertices and edges are the same, the matching still may be only inexact.
|
||||
Two categories of search methods are the ones based on identification of possible and impossible pairings of vertices between the two graphs and methods that formulate graph matching as an optimization problem. Graph edit distance is one of similarity measures suggested for graph matching. The class of algorithms is called error-tolerant graph matching.
|
||||
|
||||
|
||||
== See also ==
|
||||
String matching
|
||||
Pattern matching
|
||||
|
||||
|
||||
== References ==
|
||||
24
data/en.wikipedia.org/wiki/Graphics_Turing_test-0.md
Normal file
24
data/en.wikipedia.org/wiki/Graphics_Turing_test-0.md
Normal file
@ -0,0 +1,24 @@
|
||||
---
|
||||
title: "Graphics Turing test"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Graphics_Turing_test"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:15.479211+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
In computer graphics the graphics Turing test is a variant of the Turing test, the twist being that a human judge viewing and interacting with an artificially generated world should be unable to reliably distinguish it from reality.
|
||||
The original formulation of the test is:
|
||||
|
||||
"The subject views and interacts with a real or computer generated scene. The test is passed if the subject can not determine reality from simulated reality better than a random guess. (a) The subject operates a remotely controlled (or simulated) robotic arm and views a computer screen. (b) The subject enters a door to a controlled vehicle or motion simulator with computer screens for windows. An eye patch can be worn on one eye, as stereo vision is difficult to simulate."
|
||||
The "graphics Turing scale" of computer power is then defined as the computing power necessary to achieve success in the test. It was estimated in, as 1036.8 TFlops peak and 518.4 TFlops sustained. Actual rendering tests with a Blue Gene supercomputer showed that current supercomputers are not up to the task scale yet.
|
||||
A restricted form of the graphic Turing test has been investigated, where test subjects look into a box, and try to tell whether the contents are real or virtual objects. For the very simple case of scenes with a cardboard pyramid or a styrofoam sphere, subjects were not able to reliably tell reality and graphics apart.
|
||||
|
||||
|
||||
== See also ==
|
||||
Virtual reality
|
||||
CAPTCHA
|
||||
|
||||
|
||||
== References ==
|
||||
@ -0,0 +1,21 @@
|
||||
---
|
||||
title: "Greedy Perimeter Stateless Routing in Wireless Networks"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Greedy_Perimeter_Stateless_Routing_in_Wireless_Networks"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:16.690316+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
The Greedy Perimeter Stateless Routing in Wireless Networks (GPSR) is a routing protocol for mobile ad-hoc networks. It was developed by B. Karp. It uses a greedy algorithm to do the routing and orbits around a perimeter.
|
||||
|
||||
|
||||
== Coordinates instead of receiver names ==
|
||||
GPSR is a geo routing method, which means that data packages are not sent to a special receiver but to coordinates. The packages should be relayed to the node that's geographically closest to the coordinates. This assumes that every node knows its own position.
|
||||
|
||||
|
||||
== Literature ==
|
||||
B.Karp: Challenges in Geographic Routing: Sparse Networks, Obstacles, and Traffic Provisioning. In DIMACS Workshop on Pervasive Networking, Piscataway, NJ, May 2001
|
||||
B.Karp: Geographic Routing for Wireless Networks. Ph.D. Dissertation, Harvard University, Cambridge, MA, October 2000
|
||||
B.Karp, H.T.Kung: Greedy Perimeter Stateless Routing for Wireless Networks. In Proceedings of the Sixth Annual ACM/IEEE International Conference on Mobile Computing and Networking (MobiCom 2000), Boston, MA, August 2000, pp. 243-254
|
||||
15
data/en.wikipedia.org/wiki/HABU_equivalent-0.md
Normal file
15
data/en.wikipedia.org/wiki/HABU_equivalent-0.md
Normal file
@ -0,0 +1,15 @@
|
||||
---
|
||||
title: "HABU equivalent"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/HABU_equivalent"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:17.858920+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
The HABU equivalent is a unit of measurement used by United States Department of Defense's High Performance Computing Modernization Program to evaluate the performance of large computers systems.
|
||||
"The [HPCMP method for measuring system performance] is as follows: the ratio of time [for a given benchmark application] at a target processor count provides a relative measure of the system's performance on that application test case compared with the DoD standard system, stated in Habu-equivalents. Habu, the first DoD standard system, is an IBM POWER3 formerly located at the US Naval Oceanographic Office (NAVO) Major Shared Resource Center. One Habu-equivalent is the performance of 1,024 system-under-study processors compared with 1,024 Habu processors.
|
||||
|
||||
|
||||
== References ==
|
||||
270
data/en.wikipedia.org/wiki/HBJ_model-0.md
Normal file
270
data/en.wikipedia.org/wiki/HBJ_model-0.md
Normal file
@ -0,0 +1,270 @@
|
||||
---
|
||||
title: "HBJ model"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/HBJ_model"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:21.513029+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
In computer science, the Helman-Bader-JaJa model
|
||||
is a concise message-passing model of parallel computing defined with the following parameters:
|
||||
|
||||
|
||||
|
||||
|
||||
p
|
||||
|
||||
|
||||
{\displaystyle p}
|
||||
|
||||
is number of processors.
|
||||
|
||||
|
||||
|
||||
|
||||
n
|
||||
|
||||
|
||||
{\displaystyle n}
|
||||
|
||||
is the problem size.
|
||||
|
||||
|
||||
|
||||
|
||||
m
|
||||
|
||||
|
||||
{\displaystyle m}
|
||||
|
||||
is number of machine words in a packet sent over the network.
|
||||
|
||||
|
||||
|
||||
|
||||
τ
|
||||
|
||||
|
||||
{\displaystyle \tau }
|
||||
|
||||
is the latency, or time at which a processor takes to initiate a communication on a network.
|
||||
|
||||
|
||||
|
||||
|
||||
σ
|
||||
|
||||
|
||||
{\displaystyle \sigma }
|
||||
|
||||
is the bandwidth, or time per machine word at which a processor can inject or receive
|
||||
|
||||
|
||||
|
||||
m
|
||||
|
||||
|
||||
{\displaystyle m}
|
||||
|
||||
machine words from the network.
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
T
|
||||
|
||||
c
|
||||
o
|
||||
m
|
||||
p
|
||||
|
||||
|
||||
|
||||
|
||||
{\displaystyle T_{comp}}
|
||||
|
||||
is the largest computation time expended on a processor.
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
T
|
||||
|
||||
c
|
||||
o
|
||||
m
|
||||
m
|
||||
|
||||
|
||||
|
||||
|
||||
{\displaystyle T_{comm}}
|
||||
|
||||
is the time spent in communication on the network.
|
||||
This model assumes that for any subset of
|
||||
|
||||
|
||||
|
||||
q
|
||||
|
||||
|
||||
{\displaystyle q}
|
||||
|
||||
processors, a block permutation among the
|
||||
|
||||
|
||||
|
||||
q
|
||||
|
||||
|
||||
{\displaystyle q}
|
||||
|
||||
processors takes
|
||||
|
||||
|
||||
|
||||
(
|
||||
τ
|
||||
+
|
||||
σ
|
||||
m
|
||||
)
|
||||
|
||||
|
||||
{\displaystyle (\tau +\sigma m)}
|
||||
|
||||
time, where
|
||||
|
||||
|
||||
|
||||
m
|
||||
|
||||
|
||||
{\displaystyle m}
|
||||
|
||||
is the size of the largest block.
|
||||
|
||||
|
||||
== Analysis of common parallel algorithms ==
|
||||
Complexities of common parallel algorithms contained in the MPI libraries:
|
||||
|
||||
Point to point communication:
|
||||
|
||||
|
||||
|
||||
O
|
||||
(
|
||||
τ
|
||||
+
|
||||
σ
|
||||
m
|
||||
)
|
||||
|
||||
|
||||
{\displaystyle O(\tau +\sigma m)}
|
||||
|
||||
|
||||
Reduction :
|
||||
|
||||
|
||||
|
||||
O
|
||||
(
|
||||
l
|
||||
o
|
||||
g
|
||||
(
|
||||
p
|
||||
)
|
||||
(
|
||||
τ
|
||||
+
|
||||
σ
|
||||
m
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
{\displaystyle O(log(p)(\tau +\sigma m))}
|
||||
|
||||
|
||||
Broadcast:
|
||||
|
||||
|
||||
|
||||
O
|
||||
(
|
||||
l
|
||||
o
|
||||
g
|
||||
(
|
||||
p
|
||||
)
|
||||
(
|
||||
τ
|
||||
+
|
||||
σ
|
||||
m
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
{\displaystyle O(log(p)(\tau +\sigma m))}
|
||||
|
||||
|
||||
Parallel prefix:
|
||||
|
||||
|
||||
|
||||
O
|
||||
(
|
||||
l
|
||||
o
|
||||
g
|
||||
(
|
||||
p
|
||||
)
|
||||
|
||||
|
||||
n
|
||||
p
|
||||
|
||||
|
||||
(
|
||||
τ
|
||||
+
|
||||
σ
|
||||
m
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
{\displaystyle O(log(p){n \over p}(\tau +\sigma m))}
|
||||
|
||||
|
||||
All to all:
|
||||
|
||||
|
||||
|
||||
O
|
||||
(
|
||||
p
|
||||
(
|
||||
τ
|
||||
+
|
||||
σ
|
||||
m
|
||||
)
|
||||
)
|
||||
)
|
||||
|
||||
|
||||
{\displaystyle O(p(\tau +\sigma m)))}
|
||||
|
||||
|
||||
|
||||
== References ==
|
||||
18
data/en.wikipedia.org/wiki/HOOD_method-0.md
Normal file
18
data/en.wikipedia.org/wiki/HOOD_method-0.md
Normal file
@ -0,0 +1,18 @@
|
||||
---
|
||||
title: "HOOD method"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/HOOD_method"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:27.522169+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
HOOD (Hierarchic Object-Oriented Design) is a detailed software design method. It is based on hierarchical decomposition of a software problem. It comprises textual and graphical representations of the design.
|
||||
HOOD was initially created for the European Space Agency (1987) and is used in such varied domains as aerospace (Eurofighter Typhoon, Helios 2 Earth Observation ground control, Ariane 5 on-board computer), ground transportation, and nuclear plants.
|
||||
HOOD main target languages are Ada, Fortran and C.
|
||||
|
||||
|
||||
== External links ==
|
||||
Introduction to HOOD HOOD page at ESA
|
||||
ESA's HOOD user manual, gzipped postscript
|
||||
20
data/en.wikipedia.org/wiki/Hardware_compatibility_list-0.md
Normal file
20
data/en.wikipedia.org/wiki/Hardware_compatibility_list-0.md
Normal file
@ -0,0 +1,20 @@
|
||||
---
|
||||
title: "Hardware compatibility list"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Hardware_compatibility_list"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:19.028115+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
A hardware compatibility list (HCL) is a list of computer hardware (typically including many types of peripheral devices) that is compatible with a particular operating system or device management software. The list contains both whole computer systems and specific hardware elements including motherboards, sound cards, and video cards. In today's world, there is a vast amount of computer hardware in circulation, and many operating systems too. A hardware compatibility list is a database of hardware models and their compatibility with a certain operating system.
|
||||
HCLs can be centrally controlled (one person or team keeps the list of hardware maintained) or user-driven (users submit reviews on hardware they have used).
|
||||
There are many HCLs. Usually, each operating system will have an official HCL on its website.
|
||||
|
||||
|
||||
== See also ==
|
||||
System requirements
|
||||
|
||||
|
||||
== References ==
|
||||
37
data/en.wikipedia.org/wiki/Hash_consing-0.md
Normal file
37
data/en.wikipedia.org/wiki/Hash_consing-0.md
Normal file
@ -0,0 +1,37 @@
|
||||
---
|
||||
title: "Hash consing"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Hash_consing"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:20.230463+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
In computer science, particularly in functional programming, hash consing is a technique used to share values that are structurally equal. When a value is constructed, such as a cons cell, the technique checks if such a value has been constructed before, and if so reuses the previous value, avoiding a new memory allocation. A useful property of hash consing is that two structures can be tested for equality in constant time via pointer equality, which in turn can improve efficiency of divide and conquer algorithms when data sets contain overlapping blocks. Hash consing has been shown to give dramatic performance improvements—both space and time—for symbolic and dynamic programming algorithms.
|
||||
Hash consing is most commonly implemented with hash tables storing weak references that may be garbage-collected when the data stored therein contains no references from outside the table.
|
||||
|
||||
|
||||
== Example ==
|
||||
The following is a simple (though inefficient) demonstration of a memoizer by means of hash table and weak references in Scheme. The bwp-object function returns true if the reference given is a broken weak pointer, i.e., the target has been garbage-collected.
|
||||
|
||||
|
||||
== History ==
|
||||
A hash consing compilation technique was presented by A.P. Ershov in 1958. The term "hash consing" originates from implementations in the context of Lisp in the 1970s.
|
||||
|
||||
|
||||
== See also ==
|
||||
String interning
|
||||
Flyweight pattern
|
||||
Merkle tree
|
||||
Hashlife
|
||||
Interning
|
||||
|
||||
|
||||
== References ==
|
||||
|
||||
|
||||
=== Further reading ===
|
||||
Goto, Eiichi (1974-05-01), Monocopy and Associative Algorithms in an Extended Lisp, retrieved 2025-08-09
|
||||
Ershov, A.P. (1958). "On programming of arithmetic operations". Communications of the ACM. 1 (8): 3–6. doi:10.1145/368892.368907. S2CID 15986378.
|
||||
Jean Goubault. Implementing Functional Languages with Fast Equality, Sets and Maps: an Exercise in Hash Consing. In Journées Francophones des Langages Applicatifs (JFLA’93), pages 222–238, Annecy, February 1993.
|
||||
629
data/en.wikipedia.org/wiki/Hennessy–Milner_logic-0.md
Normal file
629
data/en.wikipedia.org/wiki/Hennessy–Milner_logic-0.md
Normal file
@ -0,0 +1,629 @@
|
||||
---
|
||||
title: "Hennessy–Milner logic"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Hennessy–Milner_logic"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:22.714720+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
In computer science, Hennessy–Milner logic (HML) is a dynamic logic used to specify properties of a labeled transition system (LTS), a structure similar to an automaton. It was introduced in 1980 by Matthew Hennessy and Robin Milner in their paper "On observing nondeterminism and concurrency" (ICALP).
|
||||
Another variant of the HML involves the use of recursion to extend the expressibility of the logic, and is commonly referred to as 'Hennessy-Milner Logic with recursion'. Recursion is enabled with the use of maximum and minimum fixed points.
|
||||
|
||||
|
||||
== Syntax ==
|
||||
A formula is defined by the following BNF grammar for Act some set of actions:
|
||||
|
||||
|
||||
|
||||
|
||||
Φ
|
||||
::=
|
||||
|
||||
|
||||
tt
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
ff
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
Φ
|
||||
|
||||
1
|
||||
|
||||
|
||||
∧
|
||||
|
||||
Φ
|
||||
|
||||
2
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
Φ
|
||||
|
||||
1
|
||||
|
||||
|
||||
∨
|
||||
|
||||
Φ
|
||||
|
||||
2
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
||||
|
||||
|
||||
|
||||
|
||||
[
|
||||
A
|
||||
c
|
||||
t
|
||||
]
|
||||
Φ
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
||||
|
||||
|
||||
|
||||
|
||||
⟨
|
||||
A
|
||||
c
|
||||
t
|
||||
⟩
|
||||
Φ
|
||||
|
||||
|
||||
{\displaystyle \Phi ::={\textit {tt}}\,\,\,|\,\,\,{\textit {ff}}\,\,\,|\,\,\,\Phi _{1}\land \Phi _{2}\,\,\,|\,\,\,\Phi _{1}\lor \Phi _{2}\,\,\,|\,\,\,[Act]\Phi \,\,\,|\,\,\,\langle Act\rangle \Phi }
|
||||
|
||||
|
||||
That is, a formula can be
|
||||
|
||||
constant truth
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
tt
|
||||
|
||||
|
||||
|
||||
|
||||
{\displaystyle {\textit {tt}}}
|
||||
|
||||
|
||||
always true
|
||||
constant false
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
ff
|
||||
|
||||
|
||||
|
||||
|
||||
{\displaystyle {\textit {ff}}}
|
||||
|
||||
|
||||
always false
|
||||
formula conjunction
|
||||
formula disjunction
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
[
|
||||
A
|
||||
c
|
||||
t
|
||||
]
|
||||
Φ
|
||||
|
||||
|
||||
|
||||
|
||||
{\displaystyle \scriptstyle {[Act]\Phi }}
|
||||
|
||||
formula
|
||||
for all Act-derivatives, Φ must hold
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
⟨
|
||||
A
|
||||
c
|
||||
t
|
||||
⟩
|
||||
Φ
|
||||
|
||||
|
||||
|
||||
|
||||
{\displaystyle \scriptstyle {\langle Act\rangle \Phi }}
|
||||
|
||||
formula
|
||||
for some Act-derivative, Φ must hold
|
||||
|
||||
|
||||
== Formal semantics ==
|
||||
Let
|
||||
|
||||
|
||||
|
||||
L
|
||||
=
|
||||
(
|
||||
S
|
||||
,
|
||||
|
||||
|
||||
A
|
||||
c
|
||||
t
|
||||
|
||||
|
||||
,
|
||||
→
|
||||
)
|
||||
|
||||
|
||||
{\displaystyle L=(S,{\mathsf {Act}},\rightarrow )}
|
||||
|
||||
be a labeled transition system (LTS), and let
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
H
|
||||
M
|
||||
L
|
||||
|
||||
|
||||
|
||||
|
||||
{\displaystyle {\mathsf {HML}}}
|
||||
|
||||
be the set of HML formulae. The satisfiability
|
||||
relation
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
⊨
|
||||
|
||||
|
||||
|
||||
⊆
|
||||
(
|
||||
S
|
||||
×
|
||||
|
||||
|
||||
H
|
||||
M
|
||||
L
|
||||
|
||||
|
||||
)
|
||||
|
||||
|
||||
{\displaystyle {}\models {}\subseteq (S\times {\mathsf {HML}})}
|
||||
|
||||
relates states of the LTS
|
||||
to the formulae they satisfy, and is defined as the smallest relation such that, for all states
|
||||
|
||||
|
||||
|
||||
s
|
||||
∈
|
||||
S
|
||||
|
||||
|
||||
{\displaystyle s\in S}
|
||||
|
||||
|
||||
and formulae
|
||||
|
||||
|
||||
|
||||
ϕ
|
||||
,
|
||||
|
||||
ϕ
|
||||
|
||||
1
|
||||
|
||||
|
||||
,
|
||||
|
||||
ϕ
|
||||
|
||||
2
|
||||
|
||||
|
||||
∈
|
||||
|
||||
|
||||
H
|
||||
M
|
||||
L
|
||||
|
||||
|
||||
|
||||
|
||||
{\displaystyle \phi ,\phi _{1},\phi _{2}\in {\mathsf {HML}}}
|
||||
|
||||
,
|
||||
|
||||
|
||||
|
||||
|
||||
s
|
||||
⊨
|
||||
|
||||
|
||||
tt
|
||||
|
||||
|
||||
|
||||
|
||||
{\displaystyle s\models {\textit {tt}}}
|
||||
|
||||
,
|
||||
there is no state
|
||||
|
||||
|
||||
|
||||
s
|
||||
∈
|
||||
S
|
||||
|
||||
|
||||
{\displaystyle s\in S}
|
||||
|
||||
for which
|
||||
|
||||
|
||||
|
||||
s
|
||||
⊨
|
||||
|
||||
|
||||
ff
|
||||
|
||||
|
||||
|
||||
|
||||
{\displaystyle s\models {\textit {ff}}}
|
||||
|
||||
,
|
||||
if there exists a state
|
||||
|
||||
|
||||
|
||||
|
||||
s
|
||||
′
|
||||
|
||||
∈
|
||||
S
|
||||
|
||||
|
||||
{\displaystyle s'\in S}
|
||||
|
||||
such that
|
||||
|
||||
|
||||
|
||||
s
|
||||
|
||||
|
||||
→
|
||||
|
||||
a
|
||||
|
||||
|
||||
|
||||
|
||||
s
|
||||
′
|
||||
|
||||
|
||||
|
||||
{\displaystyle s{\xrightarrow {a}}s'}
|
||||
|
||||
and
|
||||
|
||||
|
||||
|
||||
|
||||
s
|
||||
′
|
||||
|
||||
⊨
|
||||
ϕ
|
||||
|
||||
|
||||
{\displaystyle s'\models \phi }
|
||||
|
||||
, then
|
||||
|
||||
|
||||
|
||||
s
|
||||
⊨
|
||||
⟨
|
||||
a
|
||||
⟩
|
||||
ϕ
|
||||
|
||||
|
||||
{\displaystyle s\models \langle a\rangle \phi }
|
||||
|
||||
,
|
||||
if for all
|
||||
|
||||
|
||||
|
||||
|
||||
s
|
||||
′
|
||||
|
||||
∈
|
||||
S
|
||||
|
||||
|
||||
{\displaystyle s'\in S}
|
||||
|
||||
such that
|
||||
|
||||
|
||||
|
||||
s
|
||||
|
||||
|
||||
→
|
||||
|
||||
a
|
||||
|
||||
|
||||
|
||||
|
||||
s
|
||||
′
|
||||
|
||||
|
||||
|
||||
{\displaystyle s{\xrightarrow {a}}s'}
|
||||
|
||||
it holds that
|
||||
|
||||
|
||||
|
||||
|
||||
s
|
||||
′
|
||||
|
||||
⊨
|
||||
ϕ
|
||||
|
||||
|
||||
{\displaystyle s'\models \phi }
|
||||
|
||||
, then
|
||||
|
||||
|
||||
|
||||
s
|
||||
⊨
|
||||
[
|
||||
a
|
||||
]
|
||||
ϕ
|
||||
|
||||
|
||||
{\displaystyle s\models [a]\phi }
|
||||
|
||||
,
|
||||
if
|
||||
|
||||
|
||||
|
||||
s
|
||||
⊨
|
||||
|
||||
ϕ
|
||||
|
||||
1
|
||||
|
||||
|
||||
|
||||
|
||||
{\displaystyle s\models \phi _{1}}
|
||||
|
||||
, then
|
||||
|
||||
|
||||
|
||||
s
|
||||
⊨
|
||||
|
||||
ϕ
|
||||
|
||||
1
|
||||
|
||||
|
||||
∨
|
||||
|
||||
ϕ
|
||||
|
||||
2
|
||||
|
||||
|
||||
|
||||
|
||||
{\displaystyle s\models \phi _{1}\lor \phi _{2}}
|
||||
|
||||
,
|
||||
if
|
||||
|
||||
|
||||
|
||||
s
|
||||
⊨
|
||||
|
||||
ϕ
|
||||
|
||||
2
|
||||
|
||||
|
||||
|
||||
|
||||
{\displaystyle s\models \phi _{2}}
|
||||
|
||||
, then
|
||||
|
||||
|
||||
|
||||
s
|
||||
⊨
|
||||
|
||||
ϕ
|
||||
|
||||
1
|
||||
|
||||
|
||||
∨
|
||||
|
||||
ϕ
|
||||
|
||||
2
|
||||
|
||||
|
||||
|
||||
|
||||
{\displaystyle s\models \phi _{1}\lor \phi _{2}}
|
||||
|
||||
,
|
||||
if
|
||||
|
||||
|
||||
|
||||
s
|
||||
⊨
|
||||
|
||||
ϕ
|
||||
|
||||
1
|
||||
|
||||
|
||||
|
||||
|
||||
{\displaystyle s\models \phi _{1}}
|
||||
|
||||
and
|
||||
|
||||
|
||||
|
||||
s
|
||||
⊨
|
||||
|
||||
ϕ
|
||||
|
||||
2
|
||||
|
||||
|
||||
|
||||
|
||||
{\displaystyle s\models \phi _{2}}
|
||||
|
||||
, then
|
||||
|
||||
|
||||
|
||||
s
|
||||
⊨
|
||||
|
||||
ϕ
|
||||
|
||||
1
|
||||
|
||||
|
||||
∧
|
||||
|
||||
ϕ
|
||||
|
||||
2
|
||||
|
||||
|
||||
|
||||
|
||||
{\displaystyle s\models \phi _{1}\land \phi _{2}}
|
||||
|
||||
.
|
||||
|
||||
|
||||
== See also ==
|
||||
The modal μ-calculus, which extends HML with fixed point operators
|
||||
Dynamic logic, a multimodal logic with infinitely many modalities
|
||||
|
||||
|
||||
== References ==
|
||||
|
||||
|
||||
== Sources ==
|
||||
Colin P. Stirling (2001). Modal and temporal properties of processes. Springer. pp. 32–39. ISBN 978-0-387-98717-0.
|
||||
Sören Holmström. 1988. "Hennessy-Milner Logic with Recursion as a Specification Language, and a Refinement Calculus based on It". In Proceedings of the BCS-FACS Workshop on Specification and Verification of Concurrent Systems, Charles Rattray (Ed.). Springer-Verlag, London, UK, 294–330.
|
||||
25
data/en.wikipedia.org/wiki/High-level_assembler-0.md
Normal file
25
data/en.wikipedia.org/wiki/High-level_assembler-0.md
Normal file
@ -0,0 +1,25 @@
|
||||
---
|
||||
title: "High-level assembler"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/High-level_assembler"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:25.134956+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
A high-level assembler in computing is an assembler for assembly language that incorporate features found in a high-level programming language.
|
||||
The earliest high-level assembler was probably Burroughs' Executive Systems Problem Oriented Language (ESPOL) in about 1960, which provided an ALGOL-like syntax around explicitly-specified Burroughs B5000 machine instructions. This was followed by Niklaus Wirth's PL360 in 1968; this replicated the Burroughs facilities, with which he was familiar, on an IBM System/360. More recent high-level assemblers are Borland's Turbo Assembler (TASM), Netwide Assembler (NASM), Microsoft's Macro Assembler (MASM), IBM's High Level Assembler (HLASM) for z/Architecture systems, Alessandro Ghignola's Linoleum, X# used in Cosmos and Ziron.
|
||||
High-level assemblers typically provide instructions that directly assemble one-to-one into low-level machine code as in any assembler, plus control statements such as IF, WHILE, REPEAT...UNTIL, and FOR, macros, and other enhancements. This allows the use of high-level control statement abstractions wherever maximal speed or minimal space is not essential; low-level statements that assemble directly to machine code can be used to produce the fastest or shortest code. The end result is assembly source code that is far more readable than standard assembly code while preserving the efficiency inherent with using assembly language.
|
||||
High-level assemblers generally provide information-hiding facilities and the ability to call functions and procedures using a high-level-like syntax (i.e., the assembler automatically produces code to push parameters on the call stack rather than the programmer having to manually write the code to do this).
|
||||
High-level assemblers also provide data abstractions normally found in high-level languages. Examples include: data structures, unions, classes, and sets. Some high-level assemblers (e.g., TASM and High Level Assembly (HLA)) support object-oriented programming.
|
||||
|
||||
|
||||
== References ==
|
||||
Salomon, David (February 1993) [1992]. Written at California State University, Northridge, California, USA. Chivers, Ian D. (ed.). Assemblers and Loaders (PDF). Ellis Horwood Series In Computers And Their Applications (1 ed.). Chicester, West Sussex, UK: Ellis Horwood Limited / Simon & Schuster International Group. ISBN 0-13-052564-2. Archived (PDF) from the original on 2020-03-23. Retrieved 2008-10-01. [1][2] (xiv+294+4 pages) (NB. Presents definitions and examples of older high-level assemblers.)
|
||||
Randall Hyde (2010). The Art of Assembly Language (2nd ed.). ISBN 978-1-5932-7207-4.
|
||||
|
||||
|
||||
== External links ==
|
||||
HAL70 , Hamish Dewar [3] A high level assembly language for Interdata series 70 mini-computers.
|
||||
Webster site with information and links on HLA and assembler
|
||||
@ -0,0 +1,38 @@
|
||||
---
|
||||
title: "High Performance Knowledge Bases"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/High_Performance_Knowledge_Bases"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:23.907665+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
The High Performance Knowledge Bases (HPKB) was a DARPA research program to advance the technology of how computers acquire, represent and manipulate knowledge. The successor of the HPKB project was the Rapid Knowledge Formation (RKF) project.
|
||||
The primary results of the HPKB project was to focus further research on the Knowledge acquisition bottleneck problem.
|
||||
HPKB was divided programmatically into three groups:
|
||||
|
||||
Integrators
|
||||
Technology developers
|
||||
Challenge problem developers
|
||||
|
||||
|
||||
== See also ==
|
||||
Knowledge base
|
||||
Cyc - commercial knowledge base
|
||||
OpenCyc - Open source version of Cyc
|
||||
Electronic Directory Research (EDR) - Japanese large knowledge base effort
|
||||
Project Halo - Ultimate successor project
|
||||
Rapid Knowledge Formation (RKF)- follow-on project
|
||||
SUMO - Suggested Upper Merged Ontology
|
||||
Wikipedia - example of large knowledge base that is not yet semantically parsable
|
||||
WordNet - a semantic network of words, terms used in the English language
|
||||
|
||||
|
||||
== External links ==
|
||||
[1] DARPA HPKB Home Page
|
||||
Cohen, P., Schrag, R., Jones, E., Pease, A., Lin, A., Starr, B., Gunning, D. and Burke, M. DARPA High-Performance Knowledge Bases Project AI Magazine Volume 19 Number 4 (1998)
|
||||
|
||||
|
||||
== References ==
|
||||
Web Intelligence: First Asia-Pacific Conference, Wi 2001, Maebashi City, Japan, October 23–26, by N Zhong, Y Yao, J Liu
|
||||
21
data/en.wikipedia.org/wiki/Highway_network_optimization-0.md
Normal file
21
data/en.wikipedia.org/wiki/Highway_network_optimization-0.md
Normal file
@ -0,0 +1,21 @@
|
||||
---
|
||||
title: "Highway network optimization"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Highway_network_optimization"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:26.368139+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
Highway network optimization is the problem of configuring highway networks to maximize economic and social utility. Numerous mathematical optimization techniques have been brought to bear on the problem, including linear programming and deep learning.
|
||||
Recent research has included work on treating the highway optimization problem as a dynamic system.
|
||||
|
||||
|
||||
== References ==
|
||||
|
||||
|
||||
== See also ==
|
||||
Traffic engineering
|
||||
Transit route network design problem
|
||||
Liner shipping network design and scheduling problem
|
||||
27
data/en.wikipedia.org/wiki/Hooksafe-0.md
Normal file
27
data/en.wikipedia.org/wiki/Hooksafe-0.md
Normal file
@ -0,0 +1,27 @@
|
||||
---
|
||||
title: "Hooksafe"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Hooksafe"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:28.749131+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
Hooksafe is a hypervisor-based lightweight system that protects an operating system's kernel hooks from rootkit attacks.
|
||||
It prevents thousands of kernel hooks in the guest operating system from being hijacked. This is achieved by making a shadow copy of all the kernel hooks at one central place and adding an indirection layer on it to regulate attempts to access the hooks. A prototype of Hooksafe was used on a Linux guest and protected nearly 6000 kernel hooks. It focuses on protecting kernel control data that are function pointers. It provides large scale hook protection with small performance overhead
|
||||
|
||||
|
||||
== History ==
|
||||
Prior rootkit thwarting systems include: Panorama, Hookfinder and systems focused on analyzing rootkit behavior, Copilot, VMwatcher and systems that detect rootkits based on symptoms, Patagonix, NICKLE and systems aimed to preserve kernel code integrity by preventing malicious rootkit code from executing.
|
||||
|
||||
|
||||
== See also ==
|
||||
Rootkit
|
||||
|
||||
|
||||
== References ==
|
||||
|
||||
|
||||
== External links ==
|
||||
VMwatcher
|
||||
@ -0,0 +1,37 @@
|
||||
---
|
||||
title: "Human-readable medium and data"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Human-readable_medium_and_data"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:29.956799+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
In computing, a human-readable medium or human-readable format is any encoding of data or information that can be naturally read by humans, resulting in human-readable data. It is often encoded as ASCII or Unicode text, rather than as binary data.
|
||||
In most contexts, the alternative to a human-readable representation is a machine-readable format or medium of data primarily designed for reading by electronic, mechanical or optical devices, or computers. For example, Universal Product Code (UPC) barcodes are very difficult to read for humans, but very effective and reliable with the proper equipment, whereas the strings of numerals that commonly accompany the label are the human-readable form of the barcode information. Since any type of data encoding can be parsed by a suitably programmed computer, the decision to use binary encoding rather than text encoding is usually made to conserve storage space. Encoding data in a binary format typically requires fewer bytes of storage and increases efficiency of access (input and output) by eliminating format parsing or conversion.
|
||||
With the advent of standardized, highly structured markup languages, such as Extensible Markup Language (XML), the decreasing costs of data storage, and faster and cheaper data communication networks, compromises between human-readability and machine-readability are now more common-place than they were in the past. This has led to humane markup languages and modern configuration file formats that are far easier for humans to read.
|
||||
In addition, these structured representations can be compressed very effectively for transmission or storage.
|
||||
Human-readable protocols greatly reduce the cost of debugging.
|
||||
Various organizations have standardized the definition of human-readable and machine-readable data and how they are applied in their respective fields of application, e.g., the Universal Postal Union.
|
||||
Often the term human-readable is also used to describe shorter names or strings, that are easier to comprehend or to remember than long, complex syntax notations, such as some Uniform Resource Locator strings.
|
||||
Occasionally "human-readable" is used to describe ways of encoding an arbitrary integer into a long series of English words.
|
||||
Compared to decimal or other compact binary-to-text encoding systems,
|
||||
English words are easier for humans to read, remember, and type in.
|
||||
|
||||
|
||||
== See also ==
|
||||
Self-documenting code – source code that is both machine-readable and human-readable
|
||||
Human-readable code
|
||||
Machine-Readable Documents
|
||||
Machine-readable data
|
||||
Data (computing)
|
||||
Data conversion
|
||||
Hellschreiber
|
||||
Human–computer interaction
|
||||
Human factors
|
||||
Plain text
|
||||
Quoted printable
|
||||
|
||||
|
||||
== References ==
|
||||
22
data/en.wikipedia.org/wiki/Hyperscale_computing-0.md
Normal file
22
data/en.wikipedia.org/wiki/Hyperscale_computing-0.md
Normal file
@ -0,0 +1,22 @@
|
||||
---
|
||||
title: "Hyperscale computing"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Hyperscale_computing"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:31.118762+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
In computing, hyperscale is the ability of an architecture to scale appropriately as increased demand is added to the system.
|
||||
This typically involves the ability to seamlessly provide and add computing, memory, networking, and storage resources to a given node or set of nodes that make up a larger computing, distributed computing, or grid computing environment. Hyperscale computing is necessary in order to build a robust and scalable cloud, big data, map reduce, or distributed storage system and is often associated with the infrastructure required to run large distributed sites such as Google, Facebook, Twitter, Amazon, Microsoft, IBM Cloud, Oracle Cloud, or Cloudflare.
|
||||
Companies like Ericsson, AMD, and Intel provide hyperscale infrastructure kits for IT service providers.
|
||||
Companies like Scaleway, Switch, Alibaba, IBM, QTS, Neysa, Digital Realty Trust, Equinix, Oracle, Meta, Amazon Web Services, SAP, Microsoft, Google, and Cloudflare build data centers for hyperscale computing. Such companies are sometimes called "hyperscalers". They are recognized for their massive scale in cloud computing and data management, operating in environments that require extensive infrastructure to accommodate large-scale data processing and storage.
|
||||
|
||||
|
||||
== See also ==
|
||||
Software-defined networking
|
||||
Software-defined storage
|
||||
|
||||
|
||||
== References ==
|
||||
20
data/en.wikipedia.org/wiki/IBM_Laboratory_Vienna-0.md
Normal file
20
data/en.wikipedia.org/wiki/IBM_Laboratory_Vienna-0.md
Normal file
@ -0,0 +1,20 @@
|
||||
---
|
||||
title: "IBM Laboratory Vienna"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/IBM_Laboratory_Vienna"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:32.328791+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
IBM Laboratory Vienna was an IBM research laboratory based in Vienna, Austria.
|
||||
The laboratory started with a group led by Heinz Zemanek that moved from the Technische Hochschule (now the Technical University of Vienna). Initially, the group worked on computer hardware projects. Later a compiler for the ALGOL 60 programming language was produced. The group built on ideas of Calvin C. Elgot, Peter Landin, and John McCarthy, to create an operational semantics that could define the whole of IBM's PL/I programming language. The meta-language used for this was dubbed by people outside the laboratory as the Vienna Definition Language (VDL). These descriptions were used for compiler design research into compiler design during 1968–70.
|
||||
The formal method VDM (Vienna Development Method) was a result of research at the laboratory by Dines Bjørner, Cliff Jones, Peter Lucas, and others.
|
||||
|
||||
|
||||
== See also ==
|
||||
IBM Research
|
||||
|
||||
|
||||
== References ==
|
||||
28
data/en.wikipedia.org/wiki/IBM_WebFountain-0.md
Normal file
28
data/en.wikipedia.org/wiki/IBM_WebFountain-0.md
Normal file
@ -0,0 +1,28 @@
|
||||
---
|
||||
title: "IBM WebFountain"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/IBM_WebFountain"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:33.608982+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
WebFountain is an Internet analytical engine implemented by IBM for the study of unstructured data on the World Wide Web. IBM describes WebFountain as:
|
||||
|
||||
. . . a set of research technologies that collect, store and analyze massive amounts of unstructured and semi-structured text. It is built on an open, extensible platform that enables the discovery of trends, patterns and relationships from data.
|
||||
The project represents one of the first comprehensive attempts to catalog and interpret the unstructured data of the Web in a continuous fashion. To this end its supporting researchers at IBM have investigated new systems for the precise retrieval of subsets of the information on the Web, real-time trend analysis, and meta-level analysis of the available information of the Web.
|
||||
Factiva, an information retrieval company owned by Dow Jones and Reuters, licensed WebFountain in September 2003, and has been building software which utilizes the WebFountain engine to gauge corporate reputation. Factiva reportedly offers yearly subscriptions to the service for $200,000. Factiva has since decided to explore other technologies, and has severed its relationship with WebFountain.
|
||||
WebFountain is developed at IBM's Almaden research campus in the Bay Area of California.
|
||||
IBM has developed software, called UIMA for Unstructured Information Management Architecture, that can be used for analysis of unstructured information. It can perhaps help perform trend analysis across documents, determine the theme and gist of documents, allow fuzzy searches on unstructured documents.
|
||||
|
||||
|
||||
== References ==
|
||||
|
||||
|
||||
== External links ==
|
||||
IBM Almaden Research Center WebFountain overview
|
||||
WebFountain on John Battelle's Searchblog
|
||||
Zdnet article "Drinking from the Fire Hydrant"
|
||||
Deprecated link at archive.today (archived 2012-07-21) IBM sets out to make sense of the Web, February 5, 2004
|
||||
IBM Joins Corporate Monitoring Space with Release of Public Image Monitoring Solution, Search Engine Watch, November 9, 2005
|
||||
@ -0,0 +1,18 @@
|
||||
---
|
||||
title: "IEEE Transactions on Control Systems Technology"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/IEEE_Transactions_on_Control_Systems_Technology"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:37.200997+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
The IEEE Transactions on Control Systems Technology is published bimonthly by the IEEE Control Systems Society. The journal publishes papers, letters, tutorials, surveys, and perspectives on control systems technology. The editor-in-chief is Prof. Andrea Serrani (Ohio State University). According to the Journal Citation Reports, the journal has a 2019 impact factor of 5.312.
|
||||
|
||||
|
||||
== References ==
|
||||
|
||||
|
||||
== External links ==
|
||||
Official website
|
||||
@ -4,7 +4,7 @@ chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/IJCAI_Award_for_Research_Excellence"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:23:33.124014+00:00"
|
||||
date_saved: "2026-05-05T11:34:38.442135+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
|
||||
30
data/en.wikipedia.org/wiki/IMAP_IDLE-0.md
Normal file
30
data/en.wikipedia.org/wiki/IMAP_IDLE-0.md
Normal file
@ -0,0 +1,30 @@
|
||||
---
|
||||
title: "IMAP IDLE"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/IMAP_IDLE"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:40.771607+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
In email technology, IDLE is an IMAP feature described in RFC 2177 that allows a client to indicate to the server that it is ready to accept notifications in real time.
|
||||
|
||||
|
||||
== Significance ==
|
||||
The IDLE feature allows IMAP email users to immediately receive any mailbox changes without having to undertake any action such as clicking on a refresh button, or having the email client automatically and repeatedly ask the server for new messages.
|
||||
|
||||
|
||||
== Usage ==
|
||||
IMAP4 servers that support IDLE will include the string "IDLE" in the result of their CAPABILITY command. This allows email users to receive near instant notification of a new email.
|
||||
|
||||
|
||||
== See also ==
|
||||
Push-IMAP
|
||||
|
||||
|
||||
== Notes ==
|
||||
|
||||
|
||||
== External links ==
|
||||
RFC 2177: IMAP4 IDLE
|
||||
24
data/en.wikipedia.org/wiki/ISBL-0.md
Normal file
24
data/en.wikipedia.org/wiki/ISBL-0.md
Normal file
@ -0,0 +1,24 @@
|
||||
---
|
||||
title: "ISBL"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/ISBL"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:35:03.516367+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
ISBL (Information Systems Base Language) is the relational algebra notation that was invented for PRTV, one of the earliest database management systems to implement E.F. Codd's relational model of data.
|
||||
|
||||
|
||||
== Example ==
|
||||
OS = ORDERS * SUPPLIERS
|
||||
LIST OS: NAME="Brooks" % SNAME, ITEM, PRICE
|
||||
|
||||
|
||||
== See also ==
|
||||
IBM Business System 12 - An IBM industrial strength relational DBMS influenced by ISBL. It was developed for use by customers of IBM's time-sharing service bureaux in various countries in the early 1980s.
|
||||
|
||||
|
||||
== External links ==
|
||||
Sample ISBL usage
|
||||
20
data/en.wikipedia.org/wiki/Identification_scheme-0.md
Normal file
20
data/en.wikipedia.org/wiki/Identification_scheme-0.md
Normal file
@ -0,0 +1,20 @@
|
||||
---
|
||||
title: "Identification scheme"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Identification_scheme"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:34.817649+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
In metadata, an identification scheme is used to identify unique records in a set. If a data element is used to identify a record within a data set, the data element uses the Identifier representation term. An identification scheme should be contrasted with a classification scheme. Classification schemes are used to classify individual records into categories. Many records in a data set may be in a single category.
|
||||
|
||||
|
||||
== See also ==
|
||||
Classification scheme
|
||||
Metadata
|
||||
Representation term
|
||||
|
||||
|
||||
== References ==
|
||||
28
data/en.wikipedia.org/wiki/Identity_map_pattern-0.md
Normal file
28
data/en.wikipedia.org/wiki/Identity_map_pattern-0.md
Normal file
@ -0,0 +1,28 @@
|
||||
---
|
||||
title: "Identity map pattern"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Identity_map_pattern"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:35.993384+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
In database design, the identity map pattern is a database access design pattern used to improve performance by providing a context-specific, in-memory cache to prevent duplicate retrieval of the same object data from the database.
|
||||
If the requested data has already been loaded from the database, the identity map returns the same instance of the already instantiated object, but if it has not been loaded yet, it loads it and stores the new object in the map. In this way, it follows a similar principle to lazy loading.
|
||||
There are 4 types of identity maps
|
||||
|
||||
Explicit
|
||||
Generic
|
||||
Session
|
||||
Class
|
||||
|
||||
|
||||
== See also ==
|
||||
Active record
|
||||
Identity function
|
||||
Map (mathematics)
|
||||
Lazy loading
|
||||
|
||||
|
||||
== References ==
|
||||
25
data/en.wikipedia.org/wiki/Imake-0.md
Normal file
25
data/en.wikipedia.org/wiki/Imake-0.md
Normal file
@ -0,0 +1,25 @@
|
||||
---
|
||||
title: "Imake"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Imake"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:39.614606+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
imake is a build automation system written for the X Window System. It was used by X from X11R1 (1987) to X11R6.9 (2005), and continued to be used in XFree86 (last commit 2009). It is implemented on top of the C preprocessor and make. The first version was written by Todd Brunhoff at Tektronix.
|
||||
imake generates makefiles from a template, a set of C preprocessor macro functions, and a per-directory input file called an Imakefile. This allows machine dependencies (such as compiler options, alternate command names, and special make rules) to be kept separate from the descriptions of the various items to be built.
|
||||
imake was heavily used for X and X-related software through the 1990s, and for unrelated software such as ChorusOS. It was also used for configuration management.
|
||||
With the release of X.org X11R7.0, it was replaced by GNU Autotools. (X11R6.9 and X11R7.0 were the same codebase with a different build system.). X.Org plans to use Meson in the future instead of Autotools.
|
||||
|
||||
|
||||
== Notes ==
|
||||
|
||||
|
||||
== Sources ==
|
||||
DuBois, Paul (September 1996). Software Portability with imake (2nd ed.). O'Reilly Media. ISBN 978-1-56592-226-6.
|
||||
|
||||
|
||||
== External links ==
|
||||
Software Portability with imake
|
||||
27
data/en.wikipedia.org/wiki/Implicit_invocation-0.md
Normal file
27
data/en.wikipedia.org/wiki/Implicit_invocation-0.md
Normal file
@ -0,0 +1,27 @@
|
||||
---
|
||||
title: "Implicit invocation"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Implicit_invocation"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:41.970852+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
Implicit invocation is a term used by some authors for a style of software architecture in which a system is structured around event handling, using a form of callback. It is closely related to inversion of control and what is known informally as the Hollywood principle.
|
||||
|
||||
The idea behind implicit invocation is that instead of invoking a procedure directly, a component can announce (or broadcast) one or more events. Other components in the system can register an interest in an event by associating a procedure with the event. When the event is announced the system itself invokes all of the procedures that have been registered for the event. Thus an event announcement implicitly causes the invocation of procedures in other modules.
|
||||
Implicit invocation is the core technique behind the observer pattern.
|
||||
|
||||
|
||||
== See also ==
|
||||
Spring Framework
|
||||
Qt Framework
|
||||
|
||||
|
||||
== References ==
|
||||
|
||||
|
||||
== External links ==
|
||||
An Introduction to Software Architecture by David Garlan and Mary Shaw
|
||||
An Introduction to Implicit Invocation Architectures by Benjamin Edwards
|
||||
31
data/en.wikipedia.org/wiki/Implicit_parallelism-0.md
Normal file
31
data/en.wikipedia.org/wiki/Implicit_parallelism-0.md
Normal file
@ -0,0 +1,31 @@
|
||||
---
|
||||
title: "Implicit parallelism"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Implicit_parallelism"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:43.204783+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
In computer science, implicit parallelism is a characteristic of a programming language that allows a compiler or interpreter to automatically exploit the parallelism inherent to the computations expressed by some of the language's constructs. A pure implicitly parallel language does not need special directives, operators or functions to enable parallel execution, in contrast to explicit parallelism.
|
||||
Programming languages with implicit parallelism include Axum, Binary Modular Dataflow Machine (BMDFM), High Performance Fortran (HPF), Id, LabVIEW, MATLAB M-code, NESL, Single Assignment C (SAC), Streams and Iteration in a Single Assignment Language (SISAL), Z-level programming language (ZPL), and pH.
|
||||
|
||||
|
||||
== Example ==
|
||||
If a given problem involves performing the same operation on a group of numbers (such as taking the sine or logarithm of each in turn), a language that provides implicit parallelism might allow writing the instruction thus:
|
||||
|
||||
The compiler or interpreter can calculate the sine of each element independently, spreading the effort across multiple processors if available.
|
||||
|
||||
|
||||
== Advantages ==
|
||||
A programmer that writes implicitly parallel code does not need to worry about task division or process communication, focusing instead on the problem that their program is intended to solve. Implicit parallelism generally facilitates the design of parallel programs and therefore results in a substantial improvement of programmer productivity.
|
||||
Many of the constructs necessary to support this also add simplicity or clarity even in the absence of actual parallelism. The example above, of list comprehension in the sin() function, is a useful feature in of itself. By using implicit parallelism, languages effectively have to provide such useful constructs to users simply to support required functionality (a language without a decent for loop, for example, is one few programmers will use).
|
||||
|
||||
|
||||
== Disadvantages ==
|
||||
Languages with implicit parallelism reduce the control that a programmer has over the parallel execution of a program, resulting sometimes in suboptimal parallel efficiency. The makers of Oz language also note that their early experiments with implicit parallelism showed that implicit parallelism made debugging difficult and object models unnecessarily awkward.
|
||||
A larger issue is that every program has some parallel and some serial logic. Binary input/output (I/O), for example, requires support for such serial operations as Write() and Seek(). If implicit parallelism is desired, this creates a new requirement for constructs and keywords to support code that cannot be threaded or distributed.
|
||||
|
||||
|
||||
== Notes ==
|
||||
29
data/en.wikipedia.org/wiki/Import_and_export_of_data-0.md
Normal file
29
data/en.wikipedia.org/wiki/Import_and_export_of_data-0.md
Normal file
@ -0,0 +1,29 @@
|
||||
---
|
||||
title: "Import and export of data"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Import_and_export_of_data"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:44.327952+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
The import and export of data is the automated or semi-automated input and output of data sets between different software applications. It involves "translating" from the format used in one application into that used by another, where such translation is accomplished automatically via machine processes, such as transcoding, data transformation, and others. True exports of data often contain data in raw formats otherwise unreadable to end-users without the user interface that was designed to render it.
|
||||
Import and export of data shares semantic analogy with copying and pasting, in that sets of data are copied from one application and pasted into another. In fact, the software development behind operating system clipboards (and clipboard extender apps) greatly concerns the many details and challenges of data transformation and transcoding, in order to present the end user with the illusion of effortless copy and paste between any two apps, no matter how internally different. The "Save As" command in many applications requires much of the same engineering, when files are saved as another file format.
|
||||
The ability to import and export data (or lack of such ability) has large economic implications, because it can be resource-intensive to input data in non-automated ways (such as manual rekeying), and because lack of interoperability and data portability between systems unable to import or export data between each other causes stovepiping, lack of opportunity and efficiencies such as those seen in, for example, mash-ups, and may not suffice in its ability to search for information as enabled by tools such as grep.
|
||||
|
||||
|
||||
== See also ==
|
||||
Data dump as export from databases
|
||||
Data portability
|
||||
Solid (web decentralization project): allows users to control and export their own data
|
||||
|
||||
|
||||
== References ==
|
||||
|
||||
|
||||
== External links ==
|
||||
Media related to Import and export of data at Wikimedia Commons
|
||||
Importers Data
|
||||
|
||||
Importers Data
|
||||
34
data/en.wikipedia.org/wiki/Information-based_complexity-0.md
Normal file
34
data/en.wikipedia.org/wiki/Information-based_complexity-0.md
Normal file
@ -0,0 +1,34 @@
|
||||
---
|
||||
title: "Information-based complexity"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Information-based_complexity"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:46.688066+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
Information-based complexity (IBC) studies optimal algorithms and computational complexity for the continuous problems that arise in physical science, economics, engineering, and mathematical finance.
|
||||
|
||||
|
||||
== Further reading ==
|
||||
Traub, J. F., Iterative Methods for the Solution of Equations, Prentice Hall, 1964. Reissued Chelsea Publishing Company, 1982; Russian translation MIR, 1985; Reissued American Mathematical Society, 1998
|
||||
Traub, J. F., and Woźniakowski, H., A General Theory of Optimal Algorithms, Academic Press, New York, 1980
|
||||
Traub, J. F., Woźniakowski, H., and Wasilkowski, G. W., Information, Uncertainty, Complexity, Addison-Wesley, New York, 1983
|
||||
Novak, E., Deterministic and Stochastic Error Bounds in Numerical Analysis, Lecture Notes in Mathematics, vol. 1349, Springer-Verlag, New York, 1988
|
||||
Traub, J. F., Woźniakowski, H., and Wasilkowski, G. W. (1988). Information-Based Complexity. New York: Academic Press. ISBN 978-0126975451.{{cite book}}: CS1 maint: multiple names: authors list (link)
|
||||
Werschulz, A. G., The Computational Complexity of Differential and Integral Equations: An Information-Based Approach, Oxford University Press, New York, 1991
|
||||
Kowalski, M., Sikorski, K., and Stenger, F., Selected Topics in Approximation and Computation, Oxford University Press, Oxford, UK, 1995
|
||||
Plaskota, L., Noisy Information and Computational Complexity, Cambridge University Press, Cambridge, UK, 1996
|
||||
Traub, J. F., and Werschulz, A. G., Complexity and Information, Oxford University Press, Oxford, UK, 1998
|
||||
Ritter, K., Average-Case Analysis of Numerical Problems, Springer-Verlag, New York, 2000
|
||||
Sikorski, K., Optimal Solution of Nonlinear Equations, Oxford University Press, Oxford, UK, 2001
|
||||
Extensive bibliographies may be found in the monographs N (1988), TW (1980), TWW (1988) and TW (1998).
|
||||
The IBC website has a searchable data base of some 730 items.
|
||||
|
||||
|
||||
== External links ==
|
||||
Journal of Complexity
|
||||
Complexity and Information
|
||||
Joseph Traub
|
||||
J.F Traub, 1985. An Introduction to Information-Based Complexity Archived 2011-08-23 at the Wayback Machine
|
||||
15
data/en.wikipedia.org/wiki/Information_Harvesting-0.md
Normal file
15
data/en.wikipedia.org/wiki/Information_Harvesting-0.md
Normal file
@ -0,0 +1,15 @@
|
||||
---
|
||||
title: "Information Harvesting"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Information_Harvesting"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:45.520502+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
Information Harvesting (IH) was an early data mining product from the 1990s. It was invented by Ralphe Wiggins and produced by the Ryan Corp, later Information Harvesting Inc., of Cambridge, Massachusetts. Wiggins had a background in genetic algorithms and fuzzy logic. IH sought to infer rules from sets of data. It did this first by classifying various input variables into one of a number of bins, thereby putting some structure on the continuous variables in the input. IH then proceeds to generate rules, trading off generalization against memorization, that will infer the value of the prediction variable, possibly creating many levels of rules in the process. It included strategies for checking if overfitting took place and, if so, correcting for it. Because of its strategies for correcting for overfitting by considering more data, and refining the rules based on that data, IH might also be considered to be a form of machine learning.
|
||||
The advantage of IH, as compared with other data mining products of its time and even later, was that it provided a mechanism for finding multiple rules that would classify the data and determining, according to set criteria, the best rules to use.
|
||||
|
||||
|
||||
== References ==
|
||||
26
data/en.wikipedia.org/wiki/Input/output_completion_port-0.md
Normal file
26
data/en.wikipedia.org/wiki/Input/output_completion_port-0.md
Normal file
@ -0,0 +1,26 @@
|
||||
---
|
||||
title: "Input/output completion port"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Input/output_completion_port"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:49.044060+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
Input/output completion port (IOCP) is an API for performing multiple simultaneous asynchronous input/output operations in Windows NT versions 3.5 and later, AIX and on Solaris 10 and later. An input/output completion port object is created and associated with a number of sockets or file handles. When I/O services are requested on the object, completion is indicated by a message queued to the I/O completion port. A process requesting I/O services is not notified of completion of the I/O services, but instead checks the I/O completion port's message queue to determine the status of its I/O requests. The I/O completion port manages multiple threads and their concurrency.
|
||||
|
||||
|
||||
== See also ==
|
||||
Overlapped I/O
|
||||
kqueue
|
||||
epoll
|
||||
|
||||
|
||||
== References ==
|
||||
|
||||
|
||||
== External links ==
|
||||
Article "Inside I/O Completion Ports" at the Wayback Machine (archived November 1, 2010) by Mark Russinovich.
|
||||
IOCPSOCK - an IOCP implementation of a channel driver for the Tcl language to run on Windows NT/2K/XP/Vista
|
||||
US6223207B1 - Input/output completion port queue data structures and methods for using same
|
||||
29
data/en.wikipedia.org/wiki/Input_Field_Separators-0.md
Normal file
29
data/en.wikipedia.org/wiki/Input_Field_Separators-0.md
Normal file
@ -0,0 +1,29 @@
|
||||
---
|
||||
title: "Input Field Separators"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Input_Field_Separators"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:47.874389+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
For many command line interpreters (“shell”) of Unix operating systems, the input field separators or internal field separators or $IFS shell variable holds characters used to separate text into tokens.
|
||||
The value of IFS, (in the bash shell) typically includes the space, tab, and the newline characters by default. These whitespace characters can be visualized by issuing the "declare" command in the bash shell or printing IFS with commands like printf %s "$IFS" | od -c, printf "%q\n" "$IFS" or printf %s "$IFS" | cat -A (the latter two commands being only available in some shells and on some systems).
|
||||
From the Bash, version 4 man page:
|
||||
|
||||
The shell treats each character of $IFS as a delimiter, and splits the results of the other expansions into words on these characters.
|
||||
If IFS is unset, or its value is exactly <space><tab><newline>, the default, then sequences of <space>, <tab>, and <newline> at the beginning and end of the results of the previous expansions are ignored, and any sequence of IFS characters not at the beginning or end serves to delimit words.
|
||||
If IFS has a value other than the default, then sequences of the whitespace characters space and tab are ignored at the beginning and end of the word, as long as the whitespace character is in the value of IFS (an IFS whitespace character).
|
||||
Any character in IFS that is not IFS whitespace, along with any adjacent IFS whitespace characters, delimits a field. A sequence of IFS whitespace characters is also treated as a delimiter. If the value of IFS is null, no word splitting occurs.
|
||||
|
||||
|
||||
== IFS abbreviation ==
|
||||
According to the Open Group Base Specifications, IFS is an abbreviation for "input field separators." A newer version of this specification mentions that "this name is misleading as the IFS characters are actually used as field terminators." However IFS is often referred to as "internal field separators."
|
||||
|
||||
|
||||
== Exploits ==
|
||||
IFS was usable as an exploit in some versions of Unix. A program with root permissions could be fooled into executing user-supplied code if it ran (for instance) system("/bin/mail") and was called with $IFS set to "/", in which case it would run the program "bin" (in the current directory and thus writable by the user) with root permissions. This has been fixed by making the shells not inherit the IFS variable.
|
||||
|
||||
|
||||
== References ==
|
||||
41
data/en.wikipedia.org/wiki/Instruction_step-0.md
Normal file
41
data/en.wikipedia.org/wiki/Instruction_step-0.md
Normal file
@ -0,0 +1,41 @@
|
||||
---
|
||||
title: "Instruction step"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Instruction_step"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:50.246635+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
An instruction step is a method of executing a computer program one step at a time to determine how it is functioning. This might be to determine if the correct program flow is being followed in the program during the execution or to see if variables are set to their correct values after a single step has completed.
|
||||
|
||||
|
||||
== Hardware instruction step ==
|
||||
On earlier computers, a knob on the computer console may have enabled step-by-step execution mode to be selected and execution would then proceed by pressing a "single step" or "single cycle" button. Program status word / Memory or general purpose register read-out could then be accomplished by observing and noting the console lights.
|
||||
|
||||
|
||||
== Software instruction step ==
|
||||
On later platforms with multiple users, this method was impractical and so single step execution had to be performed using software techniques.
|
||||
|
||||
|
||||
=== Software techniques ===
|
||||
Instrumentation - requiring code to be added during compile or assembly to achieve statement stepping. Code can be added manually to achieve similar results in interpretive languages such as JavaScript.
|
||||
instruction set simulation - requiring no code modifications for instruction or statement stepping
|
||||
In some software products which facilitate debugging of High level languages, it is possible to execute an entire HLL statement at a time. This frequently involves many machine instructions and execution pauses after the last instruction in the sequence, ready for the next 'instruction' step. This requires integration with the compilation output to determine the scope of each statement.
|
||||
Full Instruction set simulators however could provide instruction stepping with or without any source, since they operate at machine code level, optionally providing full trace and debugging information to whatever higher level was available through such integration. In addition they may also optionally allow stepping through each assembly (machine) instruction generated by a HLL statement.
|
||||
Programs composed of multiple 'modules' compiled from a mixture of compiled languages, and even instructions created "on-the-fly" in dynamically allocated memory, could be accommodated using this technique.
|
||||
|
||||
|
||||
=== Examples of programs providing 'Software' instruction step ===
|
||||
SIMMON an IBM internal test system which provided instruction stepping
|
||||
|
||||
|
||||
== References ==
|
||||
|
||||
|
||||
== See also ==
|
||||
Instrumentation (computer programming)
|
||||
Instruction set simulator
|
||||
Program status word
|
||||
Instruction cycle
|
||||
@ -0,0 +1,43 @@
|
||||
---
|
||||
title: "Instrumentation (computer programming)"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Instrumentation_(computer_programming)"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:51.464916+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
In computer programming, instrumentation is the act of modifying software so that analysis can be performed on it.
|
||||
Generally, instrumentation either modifies source code or binary code. Execution environments like the JVM provide separate interfaces to add instrumentation to program executions, such as the JVMTI, which enables instrumentation during program start.
|
||||
Instrumentation enables profiling:
|
||||
measuring dynamic behavior during a test run. This is useful for properties of a program that cannot be analyzed statically with sufficient precision, such as performance and alias analysis.
|
||||
Instrumentation can include:
|
||||
|
||||
Logging events such as failures and operation start and end
|
||||
Measuring and logging the duration of operations
|
||||
|
||||
|
||||
== Limitations ==
|
||||
Instrumentation is limited by execution coverage. If the program never reaches a particular point of execution, then instrumentation at that point collects no data. For instance, if a word processor application is instrumented, but the user never activates the print feature, then the instrumentation can say nothing about the routines which are used exclusively by the printing feature.
|
||||
Instrumentation increases the execution time of a program. In some contexts, this increase might be dramatic and hence limit the application of instrumentation to debugging contexts. The instrumentation overhead differs depending on the used instrumentation technology.
|
||||
|
||||
|
||||
== See also ==
|
||||
Hooking – range of techniques used to alter or augment the behavior of an operating system, of applications, or of other software components by intercepting function calls or messages or events passed between software components.
|
||||
Instruction set simulator – simulation of all instructions at machine code level to provide instrumentation
|
||||
Runtime intelligence – technologies, managed services and practices for the collection, integration, analysis, and presentation of application usage levels, patterns, and practices.
|
||||
Software performance analysis – techniques to monitor code performance, including instrumentation.
|
||||
Hardware performance counter
|
||||
DTrace – A comprehensive dynamic tracing framework for troubleshooting kernel and application problems on production systems in real time, implemented in Solaris, macOS, FreeBSD, and many other platforms and products.
|
||||
Java Management Extensions (JMX) – Java technology for managing and monitoring applications, system objects, devices (such as printers), and service-oriented networks.
|
||||
Application Response Measurement – standardized instrumentation API for C and Java.
|
||||
Dynamic recompilation – a feature of some emulators and virtual machines where the system may recompile some part of a program during execution.
|
||||
|
||||
|
||||
== References ==
|
||||
|
||||
Introduction to Instrumentation and Tracing: Microsoft Developer Network
|
||||
Apple Developer Tools: Introduction to Instruments
|
||||
SystemTap provides free software (GPL) infrastructure to simplify the gathering of information about the running Linux system.
|
||||
cwrap Auto wrap C and C++ functions with instrumentation.
|
||||
19
data/en.wikipedia.org/wiki/Interaction_protocol-0.md
Normal file
19
data/en.wikipedia.org/wiki/Interaction_protocol-0.md
Normal file
@ -0,0 +1,19 @@
|
||||
---
|
||||
title: "Interaction protocol"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Interaction_protocol"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:52.621592+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
Within the fields of computer science and robotics, interaction protocols are possible communication scenarios between individual agents in multi-agent systems. Some protocols are described quite qualitatively (for example, many parts of the traffic code), but others have a formal model, whose implementations can be tested for conformance (for example, some cryptographic protocols).
|
||||
FIPA defines markup for interaction protocol diagrams and several standard interaction protocols, including Dutch auction, English auction and reply-response.
|
||||
|
||||
|
||||
== See also ==
|
||||
Multi-agent planning
|
||||
|
||||
|
||||
== References ==
|
||||
@ -0,0 +1,19 @@
|
||||
---
|
||||
title: "International Conference on Architectural Support for Programming Languages and Operating Systems"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/International_Conference_on_Architectural_Support_for_Programming_Languages_and_Operating_Systems"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:53.812790+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
The International Conference on Architectural Support for Programming Languages and Operating Systems (ASPLOS) is an annual interdisciplinary computer science conference organized by the Association for Computing Machinery (ACM).
|
||||
Reflecting its focus, sponsorship of the conference is made up of 50% by the ACM's Special Interest Group on Computer Architecture (SIGARCH) and 25% by each of the Special Interest Group on Programming Languages (SIGPLAN) and the Special Interest Group on Operating Systems (SIGOPS). It is a high-impact conference in computer architecture and operating systems, but less so in programming languages/software engineering.
|
||||
|
||||
|
||||
== See also ==
|
||||
List of computer science conferences
|
||||
|
||||
|
||||
== References ==
|
||||
@ -0,0 +1,68 @@
|
||||
---
|
||||
title: "International Conference on Distributed Computing Systems"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/International_Conference_on_Distributed_Computing_Systems"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:55.050803+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
The International Conference on Distributed Computing Systems (ICDCS) is the oldest conference in the field of distributed computing systems in the world. It was launched by the IEEE Computer Society Technical Committee on Distributed Processing (TCDP) in October 1979, and is sponsored by such committee. It was started as an 18-month conference until 1983 and became an annual conference since 1984. The ICDCS has a long history of significant achievements and worldwide visibility, and has recently celebrated its 37th year.
|
||||
|
||||
|
||||
== Location history ==
|
||||
2019: Dallas, Texas, United States
|
||||
2018: Vienna, Austria
|
||||
2017: Atlanta, GA, United States
|
||||
2016: Nara, Japan
|
||||
2015: Columbus, Ohio, United States
|
||||
2014: Madrid, Spain
|
||||
2013: Philadelphia, Pennsylvania, United States
|
||||
2012: Macau, China
|
||||
2011: Minneapolis, Minnesota, United States
|
||||
2010: Genoa, Italy
|
||||
2009: Montreal, Quebec, Canada
|
||||
2008: Beijing, China
|
||||
2007: Toronto, Ontario, Canada
|
||||
2006: Lisbon, Portugal
|
||||
2005: Columbus, Ohio, United States
|
||||
2004: Keio University, Japan
|
||||
2003: Providence, RI, United States
|
||||
2002: Vienna, Austria
|
||||
2001: Phoenix, AZ, United States
|
||||
2000: Taipei, Taiwan
|
||||
1999: Austin, TX, United States
|
||||
1998: Amsterdam, The Netherlands
|
||||
1997: Baltimore, MD, United States
|
||||
1996: Hong Kong
|
||||
1995: Vancouver, Canada
|
||||
1994: Poznań, Poland
|
||||
1993: Pittsburgh, PA, United States
|
||||
1992: Yokohama, Japan
|
||||
1991: Arlington, TX, United States
|
||||
1990: Paris, France
|
||||
1989: Newport Beach, CA, United States
|
||||
1988: San Jose, CA, United States
|
||||
1987: Berlin, Germany
|
||||
1986: Cambridge, MA, United States
|
||||
1985: Denver, CO, United States
|
||||
1984: San Francisco, CA, United States
|
||||
1983: Hollywood, FL, United States
|
||||
1981: Versailles, France
|
||||
1979: Huntsville, AL, United States
|
||||
|
||||
|
||||
== See also ==
|
||||
List of distributed computing conferences
|
||||
|
||||
|
||||
== External links ==
|
||||
ICDCS 2018 - July 2–July 5, 2018, Vienna, Austria
|
||||
ICDCS 2007 - June 25–June 29, 2007, Toronto, Canada.
|
||||
ICDCS 2006 - July 4–July 7, 2006, Lisbon, Portugal.
|
||||
ICDCS 2005 - July 6–July 10, 2005, Columbus, Ohio, United States.
|
||||
ICDCS 2004 - March 23–March 26, 2004, Keio University, Japan.
|
||||
ICDCS 2003 - May 19–May 22, 2003, Providence, RI, United States.
|
||||
ICDCS 2002 - July 2–July 5, 2002, Vienna, Austria.
|
||||
ICDCS 2001 - April 16–April 19, 2001, Phoenix, AZ, United States.
|
||||
@ -0,0 +1,20 @@
|
||||
---
|
||||
title: "International Conference on Logic Programming"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/International_Conference_on_Logic_Programming"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:56.295281+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
The International Conference on Logic Programming (ICLP) is an academic conference on the topic of logic programming, one of the main programming paradigms. It is organized annually by the Association for Logic Programming (ALP). The conference consists of peer-reviewed papers with the post-proceedings published in the international journal Theory and Practice of Logic Programming (TPLP), published by Cambridge University Press. The acceptance rate for TPLP papers is about 20%. Technical Communications are published as Electronic Proceedings in Theoretical Computer Science.
|
||||
The first ICLP was held in September 1982 in Marseille, France; the complete list is available on the ALP website. Every 4 years, ICLP is held in conjunction with several other logic conferences, in the Federated Logic Conferences (FLoC) series.
|
||||
ICLP ranks as A (top 14.55%) in the CORE conference ranking.
|
||||
|
||||
|
||||
== References ==
|
||||
|
||||
|
||||
== External links ==
|
||||
"Previous ICLP conferences". Association for Logic Programming. Retrieved 8 October 2023.
|
||||
@ -0,0 +1,30 @@
|
||||
---
|
||||
title: "International Joint Conference on Automated Reasoning"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/International_Joint_Conference_on_Automated_Reasoning"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:57.470913+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
The International Joint Conference on Automated Reasoning (IJCAR) is a series of conferences on the topics of automated reasoning, automated deduction, and related fields. It is organized semi-regularly as a merger of other meetings. IJCAR replaces those independent conferences in the years it takes place. The conference is organized by the organizers of the Conference on Automated Deduction (CADE), and CADE has always been one of the conferences partaking in IJCAR.
|
||||
|
||||
The first IJCAR was held in Siena, Italy on 18–22 June 2001, as a merger of CADE, FTP, and TABLEAUX, and which included the IJCAR ATP System Competition (CASC-JC) on 21 June 2001.
|
||||
The second IJCAR was held in Cork, Ireland in 2004 as a merger of CADE, FTP, TABLEAUX, FroCoS and CALCULEMUS.
|
||||
The third IJCAR was held as an independent subconference of the fourth Federated Logic Conference in Seattle, United States, and merged CADE, FTP, TABLEAUX, FroCoS and TPHOLs.
|
||||
The fourth IJCAR was held in Sydney, Australia in 2008, and merged CADE, FroCoS, FTP and TABLEAUX.
|
||||
The fifth IJCAR was held in 2010 as an independent subconference of the fifth Federated Logic Conference in Edinburgh, UK, and merged CADE, FTP, TABLEAUX, and FroCoS.
|
||||
The sixth IJCAR was held in Manchester, UK, as part of the Alan Turing Year 2012, and was collocated with the Alan Turing Centenary Conference. It again merged CADE, FTP, TABLEAUX, and FroCoS.
|
||||
The seventh IJCAR was held in Vienna, Austria, as part of the Vienna Summer of Logic in 2014, and merged CADE, TABLEAUX, and FroCoS.
|
||||
The eighth IJCAR was held in Coimbra, Portugal, in 2016, and merged CADE, TABLEAUX, and FroCoS.
|
||||
|
||||
|
||||
== References ==
|
||||
|
||||
|
||||
== External links ==
|
||||
IJCAR Home Page
|
||||
IJCAR-2006 Home Page Archived 9 February 2006 at the Wayback Machine
|
||||
IJCAR-2008 Home Page Archived 14 October 2007 at the Wayback Machine
|
||||
IJCAR 2016 Home Page
|
||||
@ -0,0 +1,23 @@
|
||||
---
|
||||
title: "International Symposium on Wearable Computers"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/International_Symposium_on_Wearable_Computers"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:58.710457+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
The International Symposium on Wearable Computers (ISWC; pronounced "iz-wic") is one of the most prominent academic conferences on wearable computing and ubiquitous computing.
|
||||
|
||||
Its first edition was held in 1997 in Cambridge, MA, USA. Since 2013, ISWC conferences have been held together alongside UbiComp, a Ubiquitous Computing conference. Proceedings from every edition are published by IEEE Press.
|
||||
|
||||
|
||||
== Overview ==
|
||||
|
||||
|
||||
== References ==
|
||||
|
||||
|
||||
== External links ==
|
||||
Official website
|
||||
21
data/en.wikipedia.org/wiki/Interrupt_coalescing-0.md
Normal file
21
data/en.wikipedia.org/wiki/Interrupt_coalescing-0.md
Normal file
@ -0,0 +1,21 @@
|
||||
---
|
||||
title: "Interrupt coalescing"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Interrupt_coalescing"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:34:59.872571+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
Interrupt coalescing, also known as interrupt moderation, is a technique in which events which would normally trigger a hardware interrupt are held back, either until a certain amount of work is pending, or a timeout timer triggers. Used correctly, this technique can reduce interrupt load by up to an order of magnitude, while only incurring relatively small latency penalties. Interrupt coalescing is typically combined with either a hardware FIFO queue or direct memory access, to allow for continued data throughput while interrupts are being held back.
|
||||
Interrupt coalescing is a common feature of modern network cards, but the technique dates back to early computer UARTs such as the 16550 UART chip used in the IBM PC's serial interface, at a time when even servicing the interrupt rates required by the low data rate serial data streams of the day was taxing for contemporary CPUs.
|
||||
Interrupt coalescing can also be implemented without support in hardware, by disabling interrupts in the interrupt controller and using timer-based polling.
|
||||
|
||||
|
||||
== See also ==
|
||||
I/O processor
|
||||
Timer coalescing
|
||||
|
||||
|
||||
== References ==
|
||||
19
data/en.wikipedia.org/wiki/Interscript-0.md
Normal file
19
data/en.wikipedia.org/wiki/Interscript-0.md
Normal file
@ -0,0 +1,19 @@
|
||||
---
|
||||
title: "Interscript"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Interscript"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:35:01.042910+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
Interscript was a rich text document markup language designed by Xerox to act as a common interchange format between disparate document formats. It was part of a system that included the Xerox Character Code Standard (XCCS) and the InterPress page description representation.
|
||||
|
||||
|
||||
== References ==
|
||||
|
||||
|
||||
== External links ==
|
||||
"Introduction to Interscript" (PDF). Xerox. 19 September 1985. Retrieved 2016-10-26.
|
||||
"INTERSCRIPT" (PDF). Xerox. March 1984. Retrieved 2016-10-26.
|
||||
19
data/en.wikipedia.org/wiki/Inverse_parser-0.md
Normal file
19
data/en.wikipedia.org/wiki/Inverse_parser-0.md
Normal file
@ -0,0 +1,19 @@
|
||||
---
|
||||
title: "Inverse parser"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Inverse_parser"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:35:02.252589+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
An inverse parser, as its name suggests, is a parser that works in reverse. Rather than the user typing into the computer, the computer presents a list of words fitting the context, and excludes words that would be unreasonable. This ensures the user knows all of their options. The concept and an implementation were originally developed and patented by Texas Instruments. A few years later, it was independently developed by Chris Crawford, a game designer, for his game, Trust & Betrayal: The Legacy of Siboot, but the implementation was different enough not to infringe on the patent.
|
||||
|
||||
|
||||
== See also ==
|
||||
Parser generator
|
||||
|
||||
|
||||
== External links ==
|
||||
How to Build an Inverse Parser, an essay by Chris Crawford originally published in the Journal of Computer Game Design
|
||||
31
data/en.wikipedia.org/wiki/JaamSim-0.md
Normal file
31
data/en.wikipedia.org/wiki/JaamSim-0.md
Normal file
@ -0,0 +1,31 @@
|
||||
---
|
||||
title: "JaamSim"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/JaamSim"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:35:04.701637+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
JaamSim is a fast and scalable discrete-event simulation software that includes a drag-and-drop user interface, interactive 3D graphics, input and output processing and model development tools and editors.
|
||||
"Out of all the OS DES projects we reviewed, JaamSim is the one with the most impressive 3D user interface that can compete against COTS DES software. [...] The fact that a non-expert user can just download and test the software in a few minutes is something that is a scarce attribute in OS projects and especially in the DES domain. [...] It is the only tool we found that is clearly industry driven [...] and this may have led to more consistent motivation and funding."
|
||||
"JaamSim provides everything which is necessary to model typical planning tasks in production and logistics and proves as a real alternative to commercial DES tools."
|
||||
JaamSim is free open-source software.
|
||||
|
||||
|
||||
== Features ==
|
||||
Drag-and-drop model building
|
||||
Animated 3D graphics
|
||||
Submodels
|
||||
Libraries of model objects
|
||||
Units for all relevant inputs, outputs, and expressions
|
||||
Version control of model inputs using standard software such as Git
|
||||
|
||||
|
||||
== References ==
|
||||
|
||||
|
||||
== External links ==
|
||||
Official website
|
||||
jaamsim on GitHub
|
||||
14
data/en.wikipedia.org/wiki/Join_selection_factor-0.md
Normal file
14
data/en.wikipedia.org/wiki/Join_selection_factor-0.md
Normal file
@ -0,0 +1,14 @@
|
||||
---
|
||||
title: "Join selection factor"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Join_selection_factor"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:35:05.862526+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
Within computing, author O'Connell defines join selection factor as "[t]he percentage (or fraction) of records in one file that will be joined with records of another file". This can be calculated when two database tables are to be joined. It is primarily concerned with query optimization.
|
||||
|
||||
|
||||
== References ==
|
||||
40
data/en.wikipedia.org/wiki/Jump_threading-0.md
Normal file
40
data/en.wikipedia.org/wiki/Jump_threading-0.md
Normal file
@ -0,0 +1,40 @@
|
||||
---
|
||||
title: "Jump threading"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Jump_threading"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:35:07.096763+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
In computing, jump threading is a compiler optimization of one jump directly to a second jump. If the second condition is a subset or inverse of the first, it can be eliminated, or threaded through the first jump. This is easily done in a single pass through the program, following acyclic chained jumps until the compiler arrives at a fixed point.
|
||||
|
||||
|
||||
== Benefits ==
|
||||
The primary benefit of jump threading is the reduction of the amount of dynamically executed jumps. This makes way for further optimizations as there is a decrease in the number of conditionals, which will improve performance. On average one can expect 2-3 instructions being omitted as a result from a successful removal of a runtime branch.
|
||||
|
||||
|
||||
== Examples ==
|
||||
The following pseudocode demonstrates when a jump may be threaded.
|
||||
|
||||
10. a = SomeNumber();
|
||||
20. IF a > 10 GOTO 50
|
||||
...
|
||||
50. IF a > 0 GOTO 100
|
||||
...
|
||||
|
||||
The jump on line 50 will always be taken if the jump on line 20 is taken. Therefore, for as long as line 100 is within the reachable range of the jump (or the size of the jump doesn't matter), the jump on line 20 may safely be modified to jump directly to line 100.
|
||||
Another example shows jump threading of 2 partial overlap conditions:
|
||||
|
||||
The above can be transformed into:
|
||||
|
||||
If the first branch is taken, x and y are both true (logical conjunction), hence evaluation of expression y || z is not needed (logical disjunction). Therefore, a jump to label jmp is performed.
|
||||
|
||||
|
||||
== See also ==
|
||||
Switch (programming)
|
||||
Spaghetti code
|
||||
|
||||
|
||||
== References ==
|
||||
@ -4,7 +4,7 @@ chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Ken_Kennedy_Award"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:23:44.112387+00:00"
|
||||
date_saved: "2026-05-05T11:35:08.353410+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
|
||||
14
data/en.wikipedia.org/wiki/Kirkpatrick–Reisch_sort-0.md
Normal file
14
data/en.wikipedia.org/wiki/Kirkpatrick–Reisch_sort-0.md
Normal file
@ -0,0 +1,14 @@
|
||||
---
|
||||
title: "Kirkpatrick–Reisch sort"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Kirkpatrick–Reisch_sort"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:35:09.511686+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
Kirkpatrick–Reisch sorting is a fast sorting algorithm for items with limited-size integer keys. It is notable for having an asymptotic time complexity that is better than radix sort.
|
||||
|
||||
|
||||
== References ==
|
||||
@ -0,0 +1,29 @@
|
||||
---
|
||||
title: "Knowledge Acquisition and Documentation Structuring"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Knowledge_Acquisition_and_Documentation_Structuring"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:35:10.737037+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
Knowledge Acquisition and Documentation Structuring (KADS) is a structured way of developing knowledge-based systems (expert systems). It was developed at the University of Amsterdam as an alternative to an evolutionary approach and is now accepted as the European standard for knowledge based systems.
|
||||
Its components are:
|
||||
|
||||
A methodology for managing knowledge engineering projects.
|
||||
A knowledge engineering workbench.
|
||||
A methodology for performing knowledge elicitation.
|
||||
KADS was further developed into CommonKADS.
|
||||
|
||||
|
||||
== KADS methodology and the industrial development of expert systems ==
|
||||
A study carried out in 1989 showed that the main reason why expert systems were not being used was an insufficiency of methods for development, especially in the construction of knowledge bases, e.g. the transfer of expertise.
|
||||
Knowledge Based Systems Analysis and Design Support (KADS) originating in the European ESPRIT project P1098 and representing 75 person-years of work, was one of the most highly developed KBs (Knowledge Based Systems) in the early 90s. This pioneering method provides two types of support for the production of KBs in an industrial approach: firstly, a lifecycle enabling a response to be made to technical and economic constraints (control of the production process, quality assurance of the system,...), and secondly a set of models which structure the production of the system, especially the tasks of analysis and the transformation of expert knowledge into a form exploitable by the machine.
|
||||
|
||||
|
||||
== References ==
|
||||
|
||||
|
||||
== External links ==
|
||||
CommonKADS website
|
||||
26
data/en.wikipedia.org/wiki/Knowledge_Interchange_Format-0.md
Normal file
26
data/en.wikipedia.org/wiki/Knowledge_Interchange_Format-0.md
Normal file
@ -0,0 +1,26 @@
|
||||
---
|
||||
title: "Knowledge Interchange Format"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Knowledge_Interchange_Format"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:35:14.290978+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
Knowledge Interchange Format (KIF) is a computer language designed to enable systems to share and re-use information from knowledge-based systems. KIF is similar to frame languages such as KL-One and LOOM but unlike such language its primary role is not intended as a framework for the expression or use of knowledge but rather for the interchange of knowledge between systems. The designers of KIF likened it to PostScript. PostScript was not designed primarily as a language to store and manipulate documents but rather as an interchange format for systems and devices to share documents. In the same way KIF is meant to facilitate sharing of knowledge across different systems that use different languages, formalisms, platforms, etc.
|
||||
KIF has a declarative semantics. It is meant to describe facts about the world rather than processes or procedures. Knowledge can be described as objects, functions, relations, and rules. It is a formal language, i.e., it can express arbitrary statements in first order logic and can support reasoners that can prove the consistency of a set of KIF statements. KIF also supports non-monotonic reasoning. KIF was created by Michael Genesereth, Richard Fikes and others participating in the DARPA knowledge sharing Effort.
|
||||
Although the original KIF group intended to submit to a formal standards body, that did not occur. A later version called Common Logic has since been developed for submission to ISO and has been approved and published. A variant called SUO-KIF is the language in which the Suggested Upper Merged Ontology is written.
|
||||
A practical application of the Knowledge interchange format is an agent communication language in a multi-agent system.
|
||||
|
||||
|
||||
== See also ==
|
||||
Knowledge Query and Manipulation Language
|
||||
|
||||
|
||||
== References ==
|
||||
|
||||
|
||||
== External links ==
|
||||
Knowledge Interchange Format page at the Stanford AI Lab
|
||||
Common Logic
|
||||
35
data/en.wikipedia.org/wiki/Knowledge_Systems_Laboratory-0.md
Normal file
35
data/en.wikipedia.org/wiki/Knowledge_Systems_Laboratory-0.md
Normal file
@ -0,0 +1,35 @@
|
||||
---
|
||||
title: "Knowledge Systems Laboratory"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Knowledge_Systems_Laboratory"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:35:15.462773+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
Knowledge Systems Laboratory (KSL) was an artificial intelligence research laboratory within the Department of Computer Science at Stanford University until 2007, located in the Gates Computer Science Building, Stanford. Work focused on knowledge representation for shareable engineering knowledge bases and systems, computational environments for modelling physical devices, architectures for adaptive intelligent systems, and expert systems for science and engineering.
|
||||
KSL had projects with Stanford Medical Informatics (SMI), the Stanford Artificial Intelligence Lab (SAIL), the Stanford Formal Reasoning Group (SFRG), the Stanford Logic Group, and the Stanford Center for Design Research (CDR).
|
||||
|
||||
|
||||
== Past members ==
|
||||
This is a partial list (in alphabetical order) of past members:
|
||||
|
||||
Edward Feigenbaum
|
||||
Richard Fikes
|
||||
Diana E. Forsythe
|
||||
Tom Gruber
|
||||
William Clancey
|
||||
Alon Y. Halevy
|
||||
Deborah L. McGuinness
|
||||
Paulo Pinheiro
|
||||
Derek H. Sleeman
|
||||
Barbara Hayes-Roth
|
||||
Bruce G. Buchanan
|
||||
Ruth Duran Huard
|
||||
Lee Brownston
|
||||
|
||||
|
||||
== References ==
|
||||
|
||||
37°25′48″N 122°10′24″W
|
||||
@ -0,0 +1,27 @@
|
||||
---
|
||||
title: "Knowledge collection from volunteer contributors"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Knowledge_collection_from_volunteer_contributors"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:35:11.951096+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
Knowledge collection from volunteer contributors (KCVC) is a subfield of knowledge acquisition within artificial intelligence which attempts to drive down the cost of acquiring the knowledge required to support automated reasoning by having the public enter knowledge in computer processable form over the internet. KCVC might be regarded as similar in spirit to Wikipedia, although the intended audience, artificial intelligence systems, differs.
|
||||
|
||||
|
||||
== History ==
|
||||
The 2005 AAAI Spring Symposium on Knowledge Collection from Volunteer Contributors (KCVC05) may have been the first research meeting on this topic.
|
||||
The first large-scale KCVC project was probably the Open Mind Common Sense (OMCS) project, initiated by Push Singh and Marvin Minsky at the MIT Media Lab. In this project, volunteers entered words or simple sentences in English in response to prompts or images. Although the resulting knowledge is not formally represented, it is provided to researchers with parses and other meta-information intended to increase its utility. Later, this group released ConceptNet, which embedded the knowledge contained in the OpenMind Common Sense database as a semantic network.
|
||||
In late 2005, Cycorp released a KCVC system called FACTory that attempts to acquire knowledge in a form directly usable for automated reasoning. It automatically generates questions in English from an underlying predicate calculus representation of candidate assertions produced by automated reading of web pages, by reviewing information previously entered directly in logical form, and by analogy and abduction.
|
||||
|
||||
|
||||
== References ==
|
||||
|
||||
|
||||
== External links ==
|
||||
Open Mind Project
|
||||
Open Mind Common Sense
|
||||
ISI's Learner
|
||||
Cycorp's FACTory
|
||||
25
data/en.wikipedia.org/wiki/Knowledge_engine-0.md
Normal file
25
data/en.wikipedia.org/wiki/Knowledge_engine-0.md
Normal file
@ -0,0 +1,25 @@
|
||||
---
|
||||
title: "Knowledge engine"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Knowledge_engine"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:35:13.134336+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
A knowledge engine is part of a decision-support system that combines data with data models and inference rules to provide an interface for people who want to make decisions or discover related data. It may involve automatically extracting and structuring knowledge from less-structured sources, using these models and rules.
|
||||
|
||||
|
||||
== History ==
|
||||
In the late 1990s, the Decision Support Group at the University of Fribourg developed a model for decision support software. This described the interface between data and models on one hand, and graphical interfaces for exploring them and making decisions on the other, as a knowledge engine. They also developed a mathematical modeling language, LPL, in concert with that work.
|
||||
With the rise of the semantic web, natural language processing, and topical knowledge bases, a number of other analytical tools have been categorized as knowledge engines, including in genomics (KnowEnG), modeling human action (PaStaNet), and speeding up general-purpose question answering.
|
||||
General-purpose search and discovery tools such as WolframAlpha have also described themselves as knowledge engines.
|
||||
|
||||
|
||||
== See also ==
|
||||
Knowledge engineering
|
||||
Knowledge engineer
|
||||
|
||||
|
||||
== References ==
|
||||
14
data/en.wikipedia.org/wiki/Known-item_search-0.md
Normal file
14
data/en.wikipedia.org/wiki/Known-item_search-0.md
Normal file
@ -0,0 +1,14 @@
|
||||
---
|
||||
title: "Known-item search"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Known-item_search"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:35:16.657351+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
Known-item search is a specialization of information exploration which represents the activities carried out by searchers who have a particular item in mind. In the context of library catalogs, known‐item search means a search for an item for which the author or title is known. Although the concept of known-item search originated in library science, it is now applied in the context of web search and other online search activities. Known-item search is distinguished from exploratory search, in which a searcher is unfamiliar with the domain of their search goal, unsure about the ways to achieve their goal, and/or unsure about what their goal is.
|
||||
|
||||
|
||||
== References ==
|
||||
18
data/en.wikipedia.org/wiki/LEGO_(proof_assistant)-0.md
Normal file
18
data/en.wikipedia.org/wiki/LEGO_(proof_assistant)-0.md
Normal file
@ -0,0 +1,18 @@
|
||||
---
|
||||
title: "LEGO (proof assistant)"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/LEGO_(proof_assistant)"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:35:29.673619+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
LEGO is a proof assistant developed by Randy Pollack at the University of Edinburgh. It implements several type theories: the Edinburgh Logical Framework (LF), the Calculus of Constructions (CoC), the Generalized Calculus of Constructions (GCC) and the Unified Theory of Dependent Types (UTT).
|
||||
|
||||
|
||||
== References ==
|
||||
|
||||
|
||||
== External links ==
|
||||
Official website
|
||||
@ -0,0 +1,23 @@
|
||||
---
|
||||
title: "Lagrangian–Eulerian advection"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Lagrangian–Eulerian_advection"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:35:17.835935+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
In scientific visualization, Lagrangian–Eulerian advection is a technique mainly used for the visualization of unsteady flows. The computer graphics generated by the technique can help scientists visualize changes in velocity fields. This technique uses a hybrid Lagrangian and Eulerian specification of the flow field. It is a special case of a line integral convolution.
|
||||
The method consists of using nearest-neighbour interpolation followed by an error correction mechanism. The Lagrangian specification is used during the integration to update the particle positions. The property of interest is advected in the Eulerian frame of reference. It was originally designed by Bruno Jobard and others for steady flows but was extended to unsteady flows.
|
||||
The main idea is to create a white noise texture of the desired resolution, which is used as a base, on top of which the vector field can be applied. That means for every particle looking backward in the vector field to find out the new value for the cell it is contained in. Then looking forward – to calculate the new position of the particle in the cell.
|
||||
In its application, the Lagrangian–Eulerian method can be accelerated using the GPUs used in common chipsets present in Nvidia and ATI Radeon graphics cards.
|
||||
Ensuring that the moving texture always follows the velocity field of the fluid, while maintaining properties of the original texture, is key to avoid visual artifacts. A new method developed in 2009 improves the results of the previous one, running real-time.
|
||||
|
||||
|
||||
== See also ==
|
||||
Lagrangian analysis
|
||||
Lagrangian drifter
|
||||
|
||||
|
||||
== References ==
|
||||
@ -0,0 +1,59 @@
|
||||
---
|
||||
title: "Lamport's distributed mutual exclusion algorithm"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Lamport's_distributed_mutual_exclusion_algorithm"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:35:18.990289+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
Lamport's Distributed Mutual Exclusion Algorithm is a contention-based algorithm for mutual exclusion on a distributed system.
|
||||
|
||||
|
||||
== Algorithm ==
|
||||
|
||||
|
||||
=== Nodal properties ===
|
||||
Every process maintains a queue of pending requests for entering critical section in order. The queues are ordered by virtual time stamps derived from Lamport timestamps.
|
||||
|
||||
|
||||
=== Algorithm ===
|
||||
Requesting process
|
||||
|
||||
Pushing its request in its own queue (ordered by time stamps)
|
||||
Sending a request to every node.
|
||||
Waiting for replies from all other nodes.
|
||||
If own request is at the head of its queue and all replies have been received, enter critical section.
|
||||
Upon exiting the critical section, remove its request from the queue and send a release message to every process.
|
||||
Other processes
|
||||
|
||||
After receiving a request, pushing the request in its own request queue (ordered by time stamps) and reply with a time stamp.
|
||||
After receiving release message, remove the corresponding request from its own request queue.
|
||||
|
||||
|
||||
== Message complexity ==
|
||||
This algorithm creates 3(N − 1) messages per request, or (N − 1) messages and 2 broadcasts. 3(N − 1) messages per request includes:
|
||||
|
||||
(N − 1) total number of requests
|
||||
(N − 1) total number of replies
|
||||
(N − 1) total number of releases
|
||||
|
||||
|
||||
== Drawbacks ==
|
||||
This algorithm has several disadvantages. They are:
|
||||
|
||||
It is very unreliable as failure of any one of the processes will halt progress.
|
||||
It has a high message complexity of 3(N − 1) messages per entry/exit into the critical section.
|
||||
|
||||
|
||||
== See also ==
|
||||
Ricart–Agrawala algorithm (an improvement over Lamport's algorithm)
|
||||
Lamport's bakery algorithm
|
||||
Raymond's algorithm
|
||||
Maekawa's algorithm
|
||||
Suzuki–Kasami algorithm
|
||||
Naimi–Trehel algorithm
|
||||
|
||||
|
||||
== References ==
|
||||
22
data/en.wikipedia.org/wiki/LaserLock-0.md
Normal file
22
data/en.wikipedia.org/wiki/LaserLock-0.md
Normal file
@ -0,0 +1,22 @@
|
||||
---
|
||||
title: "LaserLock"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/LaserLock"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:35:20.180061+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
LaserLock is a copy restriction system for CD-ROMs with 32-bit Windows applications introduced by MLS LaserLock International Inc. in 1995. LaserLock is supposed to check whether the original storage medium of a program is inserted. This check can be done regularly or only once during the installation of the program. If the disk is not accessible, an error window is displayed.
|
||||
It uses a combination of encryption software and an optical mark on the surface of the disk. The protection code is embedded into an executable file on the disk using a proprietary tool. This file, which is responsible for searching for the physical mark on the disk, is encrypted and gets multiple layers of protection against code analysis to impede reverse engineering.
|
||||
The size of the encrypted file varies from 20 MB on CD-ROMs to 40 MB on DVD-ROMs or occasionally only 5 MB.
|
||||
LaserLock includes a hidden directory on the disk which contains corrupted data. When the disk is copied, the read device encounters errors due to the hidden directory.
|
||||
Copying leads to unstable behavior of the copied software and often to bad sectors that make it impossible to use without the original disk.
|
||||
|
||||
|
||||
== Notes ==
|
||||
|
||||
|
||||
== See also ==
|
||||
Official FAQ
|
||||
@ -0,0 +1,14 @@
|
||||
---
|
||||
title: "Late acceptance hill climbing"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Late_acceptance_hill_climbing"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:35:21.376594+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
Late acceptance hill climbing, created by Yuri Bykov in 2008 is a metaheuristic search method employing local search methods used for mathematical optimization.
|
||||
|
||||
|
||||
== References ==
|
||||
47
data/en.wikipedia.org/wiki/Lava_flow_(programming)-0.md
Normal file
47
data/en.wikipedia.org/wiki/Lava_flow_(programming)-0.md
Normal file
@ -0,0 +1,47 @@
|
||||
---
|
||||
title: "Lava flow (programming)"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Lava_flow_(programming)"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:35:22.542385+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
In computer programming jargon, lava flow is an anti-pattern that occurs when computer source code written under sub-optimal conditions is deployed into a production environment and subsequently expanded upon while still in a developmental state. The term derives from the natural occurrence of lava which, once cooled, solidifies into rock that is difficult to remove. Similarly, such code becomes difficult to refactor or replace due to dependencies that arise over time, necessitating the maintenance of backward compatibility with the original, incomplete design.
|
||||
|
||||
|
||||
== Causes ==
|
||||
Lava flow can occur due to a variety of reasons within a software development process:
|
||||
|
||||
Pressure to meet deadlines leading to temporary solutions becoming permanent
|
||||
Inadequate documentation which prevents understanding of the code’s purpose
|
||||
Lack of automated tests which makes refactoring risky
|
||||
Frequent changes in the development team leading to loss of knowledge
|
||||
|
||||
|
||||
== Consequences ==
|
||||
Unrefined code that becomes part of the software’s infrastructure increases the complexity of the system and the codebase becomes increasingly difficult to understand and maintain. It leads to:
|
||||
|
||||
The need for backward compatibility which can stifle innovation and prevent adoption of newer, more efficient solutions
|
||||
Increased technical debt that accumulates over time, resulting in higher costs of change and maintenance
|
||||
Obstacles to refactoring or improving the system due to fear of breaking dependent components
|
||||
|
||||
|
||||
== Impact on teams ==
|
||||
Development teams often experience the impact of lava flow when team members cycle in and out:
|
||||
|
||||
Loss of knowledge about aspects of the system's code when original developers leave
|
||||
Reluctance among new developers to refactor unfamiliar code, leading to further complexity as they add rather than clean up
|
||||
|
||||
|
||||
== Mitigation strategies ==
|
||||
Several practices can mitigate the effects of the lava flow anti-pattern:
|
||||
|
||||
Promoting good documentation practices for clear understanding of code
|
||||
Encouraging regular code reviews to catch suboptimal practices early
|
||||
Prioritizing refactoring as an integral part of the development lifecycle
|
||||
Maintaining a comprehensive suite of automated tests to reduce risk in changes
|
||||
|
||||
|
||||
== References ==
|
||||
16
data/en.wikipedia.org/wiki/Leaf_routine-0.md
Normal file
16
data/en.wikipedia.org/wiki/Leaf_routine-0.md
Normal file
@ -0,0 +1,16 @@
|
||||
---
|
||||
title: "Leaf routine"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Leaf_routine"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:35:23.733264+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
A leaf routine, leaf subroutine, leaf function, or leaf procedure is a function that does not in turn call another function. Some compilers can apply special program optimizations to leaf routines to make them more efficient, such as the use of link registers to avoid having to push the return address on the stack, or not allocating a register window on CPU architectures descended from Berkeley RISC.
|
||||
The term "leaf" refers to their position as leaf nodes in the call graph of the program.
|
||||
Usually, most non-leaf routines call more than one other function. When this is the case, the majority of function calls in the call graph are calls to leaf routines, because a binary tree has more leaf nodes than non-leaf nodes (assuming that all non-leaf nodes have two children). Consequently, the efficiency of calls to leaf routines often has a significant effect on the efficiency of the whole program.
|
||||
|
||||
|
||||
== References ==
|
||||
24
data/en.wikipedia.org/wiki/League_of_Entropy-0.md
Normal file
24
data/en.wikipedia.org/wiki/League_of_Entropy-0.md
Normal file
@ -0,0 +1,24 @@
|
||||
---
|
||||
title: "League of Entropy"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/League_of_Entropy"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:35:24.939032+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
The League of Entropy (LoE) is a voluntary consortium of organizations working together to implement an unpredictable, bias-resistant, fully decentralized, and publicly-verifiable threshold cryptosystem designed to deliver distributed Randomness as a Service, (RaaS) among other use cases. The open-source software that powers the League of Entropy's network is called drand, (short for decentralized randomness).
|
||||
Active members of the League currently include Arbitrand, Automata Network, ChainSafe, cLabs, Cloudflare, DIA Association, Emerald Onion, École Polytechnique Fédérale de Lausanne (EPFL), Ethereum Foundation, Filecoin Foundation; Gelato Network; IPFS Force, KEN Labs, Kudelski Security, Protocol Labs, PTisp, Quantum Resistant Ledger (QRL) Foundation, Randamu, StorSwift, Tierion, University of Chile, UCL, Tangle Network, and Zama.
|
||||
The League was inaugurated in 2019 with the original founding members including Cloudflare, Protocol Labs researcher Nicolas Gailly, University of Chile, École Polytechnique Fédérale de Lausanne (EPFL), and Kudelski Security. The League was created to provide a decentralized alternative to centralized randomness beacons where random number generation may be compromised or manipulated, as occurred in the Hot Lotto fraud scandal. It is also intended to avoid the implicit trust assumptions that occur when a single organization or entity is responsible for producing randomness, as in the case of the National Institute of Standards and Technology's public randomness beacon.
|
||||
Verifiable randomness has numerous applications in blockchain computing, gaming, gambling, lotteries, elections, and privacy-preserving data management systems.
|
||||
|
||||
|
||||
== References ==
|
||||
|
||||
|
||||
== External links ==
|
||||
League of Entropy home page
|
||||
Press Room for the League of Entropy
|
||||
drand distributed randomness beacon
|
||||
NIST centralized randomness beacon
|
||||
28
data/en.wikipedia.org/wiki/Learned_sparse_retrieval-0.md
Normal file
28
data/en.wikipedia.org/wiki/Learned_sparse_retrieval-0.md
Normal file
@ -0,0 +1,28 @@
|
||||
---
|
||||
title: "Learned sparse retrieval"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Learned_sparse_retrieval"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:35:26.143298+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
Learned sparse retrieval (LSR) or sparse neural search is an approach to Information Retrieval which uses a sparse vector representation of queries and documents. It borrows techniques both from lexical bag-of-words and vector embedding algorithms, and is claimed to perform better than either alone. The best-known sparse neural search systems are SPLADE and its successor SPLADE v2. Others include DeepCT, uniCOIL, EPIC, DeepImpact, TILDE and TILDEv2, Sparta, SPLADE-max, and DistilSPLADE-max.
|
||||
Multimodal Learned Sparse Retrieval. LSR approaches have also been extended to the vision-language domain, where they are applied to multimodal data, such as the combination of text and images. This expansion enables the retrieval of relevant content across different modalities, such as finding images based on text queries or vice versa.
|
||||
Some implementations of SPLADE have similar latency to Okapi BM25 lexical search while giving as good results as state-of-the-art neural rankers on in-domain data.
|
||||
The Official SPLADE model weights and training code is released under a Creative Commons NonCommercial license. But there are other independent implementations of SPLADE++ (a variant of SPLADE models) that are released under permissive licenses.
|
||||
SPRINT is a toolkit for evaluating neural sparse retrieval systems.
|
||||
|
||||
|
||||
== Splade ==
|
||||
SPLADE (Sparse Lexical and Expansion Model) is a neural retrieval model that learns sparse vector representations for queries and documents, combining elements of traditional lexical matching with semantic representations derived from transformer-based architectures. Unlike dense retrieval models that rely on continuous vector spaces, SPLADE produces sparse outputs that are compatible with inverted index structures commonly used in information retrieval systems.
|
||||
The original SPLADE model was introduced at the 44th International ACM SIGIR Conference in 2021. An updated version, SPLADE v2, incorporated modifications to its pooling mechanisms, document expansion strategies, and training objectives using knowledge distillation. Empirical evaluations have shown improvements on benchmarks such as the TREC Deep Learning 2019 dataset and the BEIR benchmark suite.
|
||||
These models aim to maintain retrieval efficiency comparable to traditional sparse methods while enhancing semantic matching capabilities, offering a balance between effectiveness and computational cost.
|
||||
|
||||
|
||||
== External links ==
|
||||
SPLADE code base at github
|
||||
|
||||
|
||||
== Notes ==
|
||||
25
data/en.wikipedia.org/wiki/Left_corner-0.md
Normal file
25
data/en.wikipedia.org/wiki/Left_corner-0.md
Normal file
@ -0,0 +1,25 @@
|
||||
---
|
||||
title: "Left corner"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Left_corner"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:35:27.302672+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
In formal language theory, the left corner of a production rule in a context-free grammar is the left-most symbol on the right side of the rule.
|
||||
For example, in the rule A→Xα, X is the left corner.
|
||||
The left corner table associates to a symbol all possible left corners for that symbol, and the left corners of those symbols, etc.
|
||||
Given the grammar
|
||||
|
||||
S → VP
|
||||
S → NP VP
|
||||
VP → V NP
|
||||
NP → DET N
|
||||
the left corner table is as follows.
|
||||
|
||||
Left corners are used to add bottom-up filtering to a top-down parser, or top-down filtering to a bottom-up parser.
|
||||
|
||||
|
||||
== References ==
|
||||
17
data/en.wikipedia.org/wiki/Left_corner_parser-0.md
Normal file
17
data/en.wikipedia.org/wiki/Left_corner_parser-0.md
Normal file
@ -0,0 +1,17 @@
|
||||
---
|
||||
title: "Left corner parser"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Left_corner_parser"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:35:28.491907+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
In computer science, a left corner parser is a type of chart parser used for parsing context-free grammars. It combines the top-down and bottom-up approaches of parsing. The name derives from the use of the left corner of the grammar's production rules.
|
||||
An early description of a left corner parser is "A Syntax-Oriented Translator" by Peter Zilahy Ingerman.
|
||||
|
||||
|
||||
== References ==
|
||||
Blackburn, Patrick; Striegnitz, Kristina (August 29, 2002). "Left-Corner Parsing". Natural Language Processing Techniques in Prolog. Schenectady, New York: Union College Computer Science department. Retrieved 30 August 2017.
|
||||
Specific
|
||||
@ -4,7 +4,7 @@ chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Leiden_Classical"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T10:12:09.200501+00:00"
|
||||
date_saved: "2026-05-05T11:35:30.887295+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
|
||||
25
data/en.wikipedia.org/wiki/Linear_graph_grammar-0.md
Normal file
25
data/en.wikipedia.org/wiki/Linear_graph_grammar-0.md
Normal file
@ -0,0 +1,25 @@
|
||||
---
|
||||
title: "Linear graph grammar"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Linear_graph_grammar"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:35:32.074138+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
In computer science, a linear graph grammar (also a connection graph reduction system or a port graph grammar) is a class of graph grammar on which nodes have a number of ports connected together by edges and edges connect exactly two ports together. Interaction nets are a special subclass of linear graph grammars in which rewriting is confluent.
|
||||
|
||||
|
||||
== Implementations ==
|
||||
Bawden introduces linear graphs in the context of a compiler for a fragment of the Scheme programming language. Bawden and Mairson (1998) describe the design of a distributed implementation in which the linear graph is spread across many computing nodes and may freely migrate in order to make rewrites possible.
|
||||
|
||||
|
||||
== Notes ==
|
||||
|
||||
|
||||
== References ==
|
||||
Bawden, Alan (1986), Connection graphs, In Proceedings of the 1986 ACM conference on LISP and functional programming, pp. 258–265, ACM Press.
|
||||
Bawden, Alan (1992), Linear graph reduction: confronting the cost of naming, PhD dissertation, MIT.
|
||||
Bawden, Alan (1993), Implementing Distributed Systems Using Linear Naming, A.I. Technical Report No. 1627, MIT.
|
||||
Bawden and Mairson (1998), Linear naming: experimental software for optimizing communication protocols, Working paper #1, Dept. Computer Science, Brandeis University.
|
||||
@ -0,0 +1,22 @@
|
||||
---
|
||||
title: "Liner shipping network design and scheduling problem"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Liner_shipping_network_design_and_scheduling_problem"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:35:33.233956+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
The liner shipping network design and problem (LSNDP) is a mathematical optimization problem in operations research that models maritime transport logistic problems. It is of practical interest in the shipping industry, as improvements in mathematical techniques can be directly applied to real-world problems.
|
||||
The problem consist of two subproblems; 1) designing feasible services, and 2) flowing the container flows through the network.
|
||||
An industry-standard benchmark dataset, LINERLIB, is used to measure the effectiveness of mathematical approaches to the LSNDSP.
|
||||
|
||||
|
||||
== See also ==
|
||||
Transshipment
|
||||
Transit route network design problem
|
||||
Highway network optimization
|
||||
|
||||
|
||||
== References ==
|
||||
@ -0,0 +1,28 @@
|
||||
---
|
||||
title: "Living Earth Simulator Project"
|
||||
chunk: 1/1
|
||||
source: "https://en.wikipedia.org/wiki/Living_Earth_Simulator_Project"
|
||||
category: "reference"
|
||||
tags: "science, encyclopedia"
|
||||
date_saved: "2026-05-05T11:35:34.432964+00:00"
|
||||
instance: "kb-cron"
|
||||
---
|
||||
|
||||
The Living Earth simulator is a proposed massive computer simulation system intended to simulate the interactions of all aspects of life, human economic activity, climate, and other physical processes on the planet Earth as part of the FuturICT project, in response to the European FP7 "Future and Emerging Technologies Flagship" initiative.
|
||||
The Future and Emerging Technologies 'flagship' competition offered a 10-years, ~€1 billion funding to the winning teams; the competition attracted over 300 international teams.
|
||||
The FuturICT project was not selected and thus the Living Earth Simulator was never developed. The two winners, announced as of March 2013, were Graphene and Human Brain.
|
||||
|
||||
|
||||
== References ==
|
||||
|
||||
Leake, Jonathan (4 December 2011). "'Hitchhiker's Guide' PC to predict crises". The Australian. Retrieved 5 April 2012.
|
||||
Leake, Jonathan (5 December 2011). "Scientific bid to trump 'failed' economics". The Australian. Retrieved 5 April 2012.
|
||||
Weinberger, David (December 2011). "The Machine That Would Predict the Future". Scientific American. Retrieved 5 April 2012.
|
||||
Rudolf, John Collins (3 January 2011). "A 'Planetary Simulator' That Averts Crises". The New York Times. Retrieved 5 April 2012.
|
||||
|
||||
|
||||
== External links ==
|
||||
FuturICT website (archived)
|
||||
Anthony, Sebastian (6 December 2011). "Living Earth Simulator will simulate the entire world". Extreme Tech. Retrieved 5 April 2012.
|
||||
"Steven R. Bishop and Helen Susannah Moat speak about FuturICT - The Billion Europe Project: Leveraging New Technology for Social Advancement". 18 April 2012. Retrieved 4 July 2012.
|
||||
Can we really model society? scientists think we can
|
||||
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user