text stringlengths 31 999 | source stringclasses 5 values |
|---|---|
The following outline is provided as an overview of and topical guide to human–computer interaction:
Human–Computer Interaction (HCI) – the intersection of computer science and behavioral sciences — this field involves the study, planning, and design of the interaction between people (users) and computers. Attention to human-machine interaction is important, because poorly designed human-machine interfaces can lead to many unexpected problems. A classic example of this is the Three Mile Island accident where investigations concluded that the design of the human-machine interface was at least partially responsible for the disaster | https://huggingface.co/datasets/fmars/wiki_stem |
Inclusive design is a design process in which a product, service, or environment is designed to be usable for as many people as possible, particularly groups who are traditionally excluded from being able to use an interface or navigate an environment. Its focus is on fulfilling as many user needs as possible, not just as many users as possible. Historically, inclusive design has been linked to designing for people with physical disabilities, and accessibility is one of the key outcomes of inclusive design | https://huggingface.co/datasets/fmars/wiki_stem |
Interaction design, often abbreviated as IxD, is "the practice of designing interactive digital products, environments, systems, and services. ": xxvii, 30 While interaction design has an interest in form (similar to other design fields), its main area of focus rests on behavior. : xxvii, 30 Rather than analyzing how things are, interaction design synthesizes and imagines things as they could be | https://huggingface.co/datasets/fmars/wiki_stem |
The Interaction Design Foundation (IxDF) is an educational organization which produces open access educational materials online with the stated goal of "democratizing education by making world-class educational materials free for anyone, anywhere. " The platform also offers courses taught by industry experts and professors in user experience, psychology, user interface design, and more. While not accredited, the curriculum and content are structured at the graduate level, targeting at both industry and academia in the fields of interaction design, design thinking, user experience, information architecture, and user interface design | https://huggingface.co/datasets/fmars/wiki_stem |
Living labs are open innovation ecosystems in real-life environments using iterative feedback processes throughout a lifecycle approach of an innovation to create sustainable impact. They focus on co-creation, rapid prototyping & testing and scaling-up innovations & businesses, providing (different types of) joint-value to the involved stakeholders. In this context, living labs operate as intermediaries/orchestrators among citizens, research organisations, companies and government agencies/levels | https://huggingface.co/datasets/fmars/wiki_stem |
In software design, the look and feel of a graphical user interface comprises aspects of its design, including elements such as colors, shapes, layout, and typefaces (the "look"), as well as the behavior of dynamic elements such as buttons, boxes, and menus (the "feel"). The term can also refer to aspects of a non-graphical user interface (such as a command-line interface), as well as to aspects of an API – mostly to parts of an API that are not related to its functional properties. The term is used in reference to both software and websites | https://huggingface.co/datasets/fmars/wiki_stem |
The term natural mapping comes from proper and natural arrangements for the relations between controls and their movements to the outcome from such action into the world. The real function of natural mappings is to reduce the need for any information from a user’s memory to perform a task. This term is widely used in the areas of human-computer interaction (HCI) and interactive design | https://huggingface.co/datasets/fmars/wiki_stem |
Overlinking in a webpage or another hyperlinked text is the characteristic of having too many hyperlinks (links). It is characterized by:
A large proportion of the words in each sentence are rendered as links.
Links that have little information content, such as linking on specific years like 1995, or unnecessary linking of common words used in the common way, for which the reader can be expected to understand the word's full meaning in context, without any hyperlink help | https://huggingface.co/datasets/fmars/wiki_stem |
In usability and interaction design, a paper cut bug is defined as "a trivially fixable usability bug". The developers of the Ubuntu Linux-based operating system describe it as a bug that average users would encounter on their first day of using a brand new installation of the latest version of Ubuntu Desktop Edition. The analogy is with a paper cut wound—small, not seriously damaging, but surprisingly painful | https://huggingface.co/datasets/fmars/wiki_stem |
Quantum machine learning is the integration of quantum algorithms within machine learning programs. The most common use of the term refers to machine learning algorithms for the analysis of classical data executed on a quantum computer, i. e | https://huggingface.co/datasets/fmars/wiki_stem |
Quantum neural networks are computational neural network models which are based on the principles of quantum mechanics. The first ideas on quantum neural computation were published independently in 1995 by Subhash Kak and Ron Chrisley, engaging with the theory of quantum mind, which posits that quantum effects play a role in cognitive function. However, typical research in quantum neural networks involves combining classical artificial neural network models (which are widely used in machine learning for the important task of pattern recognition) with the advantages of quantum information in order to develop more efficient algorithms | https://huggingface.co/datasets/fmars/wiki_stem |
Ghost is an open-source hobbyist operating system and kernel. It has been under development since 2014 and is currently compatible with the x86 platform.
The system is based on a microkernel and features symmetric multi-processing and multitasking | https://huggingface.co/datasets/fmars/wiki_stem |
Git () is a distributed version control system that tracks changes in any set of computer files, usually used for coordinating work among programmers who are collaboratively developing source code during software development. Its goals include speed, data integrity, and support for distributed, non-linear workflows (thousands of parallel branches running on different computers). Git was originally authored by Linus Torvalds in 2005 for development of the Linux kernel, with other kernel developers contributing to its initial development | https://huggingface.co/datasets/fmars/wiki_stem |
git-annex is a distributed file synchronization system written in Haskell. It aims to solve the problem of sharing and synchronizing collections of large files independent from a commercial service or even a central server.
History
The development of git-annex began in 2010 | https://huggingface.co/datasets/fmars/wiki_stem |
Haiku is a free and open-source operating system capable of running applications written for the now-discontinued BeOS, which it is modeled after. Its development began in 2001, and the operating system became self-hosting in 2008. The first alpha release was made in September 2009, and the last alpha was released on November 2012; the first beta was released in September 2018, followed by beta 2 in June 2020, then beta 3 in July 2021 | https://huggingface.co/datasets/fmars/wiki_stem |
In computer programming, self-hosting is the use of a program as part of the toolchain or operating system that produces new versions of that same program—for example, a compiler that can compile its own source code. Self-hosting software is commonplace on personal computers and larger systems. Other programs that are typically self-hosting include kernels, assemblers, command-line interpreters and revision control software | https://huggingface.co/datasets/fmars/wiki_stem |
In software engineering, a software design pattern is a general, reusable solution to a commonly occurring problem within a given context in software design. It is not a finished design that can be transformed directly into source or machine code. Rather, it is a description or template for how to solve a problem that can be used in many different situations | https://huggingface.co/datasets/fmars/wiki_stem |
An object-oriented structural design pattern for organizing objects in loosely typed key-value stores and exposing the data using typed views. The purpose of the pattern is to achieve a high degree of flexibility between components in a strongly typed language where new properties can be added to the object-tree on the fly, without losing the support of type-safety. The pattern makes use of traits to separate different properties of a class into different interfaces | https://huggingface.co/datasets/fmars/wiki_stem |
The abstract factory pattern in software engineering is a design that provides a way to create families of related objects without imposing their concrete classes, by encapsulating a group of individual factories that have a common theme without specifying their concrete classes. According to this pattern, a client software component creates a concrete implementation of the abstract factory and then uses the generic interface of the factory to create the concrete objects that are part of the family. The client does not know which concrete objects it receives from each of these internal factories, as it uses only the generic interfaces of their products | https://huggingface.co/datasets/fmars/wiki_stem |
Action–domain–responder (ADR) is a software architectural pattern that was proposed by Paul M. Jones as a refinement of Model–view–controller (MVC) that is better suited for web applications. ADR was devised to match the request-response flow of HTTP communications more closely than MVC, which was originally designed for desktop software applications | https://huggingface.co/datasets/fmars/wiki_stem |
The active object design pattern decouples method execution from method invocation for objects that each reside in their own thread of control. The goal is to introduce concurrency, by using asynchronous method invocation and a scheduler for handling requests. The pattern consists of six elements:
A proxy, which provides an interface towards clients with publicly accessible methods | https://huggingface.co/datasets/fmars/wiki_stem |
In software engineering, the active record pattern is an architectural pattern. It is found in software that stores in-memory object data in relational databases. It was named by Martin Fowler in his 2003 book Patterns of Enterprise Application Architecture | https://huggingface.co/datasets/fmars/wiki_stem |
In software engineering, the adapter pattern is a software design pattern (also known as wrapper, an alternative naming shared with the decorator pattern) that allows the interface of an existing class to be used as another interface. It is often used to make existing classes work with others without modifying their source code.
An example is an adapter that converts the interface of a Document Object Model of an XML document into a tree structure that can be displayed | https://huggingface.co/datasets/fmars/wiki_stem |
An Aggregate pattern can refer to concepts in either statistics or computer programming. Both uses deal with considering a large case as composed of smaller, simpler, pieces.
Statistics
An aggregate pattern is an important statistical concept in many fields that rely on statistics to predict the behavior of large groups, based on the tendencies of subgroups to consistently behave in a certain way | https://huggingface.co/datasets/fmars/wiki_stem |
In software engineering, an amelioration pattern is an anti-pattern formed when an existing software design pattern was edited (i. e. rearranged, added or deleted) to better suit a particular problem so as to achieve some further effect or behavior | https://huggingface.co/datasets/fmars/wiki_stem |
In functional programming, an applicative functor, or an applicative for short, is an intermediate structure between functors and monads. Applicative functors allow for functorial computations to be sequenced (unlike plain functors), but don't allow using results from prior computations in the definition of subsequent ones (unlike monads). Applicative functors are the programming equivalent of lax monoidal functors with tensorial strength in category theory | https://huggingface.co/datasets/fmars/wiki_stem |
The Archetype pattern separates the logic from implementation; the separation is accomplished by there being two abstract classes, a decorator (for logic) and a delegate (for implementation). The Factory handles the mapping of decorator and delegate classes and returns the pair associated with a parameter or parameters passed. The interface is the contract between a decorator, a delegate and the calling class creating an Inversion of Responsibility | https://huggingface.co/datasets/fmars/wiki_stem |
An architectural pattern is a general, reusable resolution to a commonly occurring problem in software architecture within a given context. The architectural patterns address various issues in software engineering, such as computer hardware performance limitations, high availability and minimization of a business risk. Some architectural patterns have been implemented within software frameworks | https://huggingface.co/datasets/fmars/wiki_stem |
In multithreaded computer programming, asynchronous method invocation (AMI), also known as asynchronous method calls or the asynchronous pattern is a design pattern in which the call site is not blocked while waiting for the called code to finish. Instead, the calling thread is notified when the reply arrives. Polling for a reply is an undesired option | https://huggingface.co/datasets/fmars/wiki_stem |
The balking pattern is a software design pattern that only executes an action on an object when the object is in a particular state. For example, if an object reads ZIP files and a calling method invokes a get method on the object when the ZIP file is not open, the object would "balk" at the request. In the Java programming language, for example, an IllegalStateException might be thrown under these circumstances | https://huggingface.co/datasets/fmars/wiki_stem |
The binding properties pattern is combining multiple observers to force properties in different objects to be synchronized or coordinated in some way. This pattern was first described as a technique by Victor Porton. This pattern comes under concurrency patterns | https://huggingface.co/datasets/fmars/wiki_stem |
In science, computing, and engineering, a black box is a system which can be viewed in terms of its inputs and outputs (or transfer characteristics), without any knowledge of its internal workings. Its implementation is "opaque" (black). The term can be used to refer to many inner workings, such as those of a transistor, an engine, an algorithm, the human brain, or an institution or government | https://huggingface.co/datasets/fmars/wiki_stem |
The bridge pattern is a design pattern used in software engineering that is meant to "decouple an abstraction from its implementation so that the two can vary independently", introduced by the Gang of Four. The bridge uses encapsulation, aggregation, and can use inheritance to separate responsibilities into different classes.
When a class varies often, the features of object-oriented programming become very useful because changes to a program's code can be made easily with minimal prior knowledge about the program | https://huggingface.co/datasets/fmars/wiki_stem |
The builder pattern is a design pattern designed to provide a flexible solution to various object creation problems in object-oriented programming. The intent of the builder design pattern is to separate the construction of a complex object from its representation. It is one of the Gang of Four design patterns | https://huggingface.co/datasets/fmars/wiki_stem |
Business delegate is a Java EE design pattern.
This pattern is directed towards reducing the coupling in between business services and the connected presentation tier, and to hide the implementation details of services (including lookup and accessibility of EJB architecture). Business delegates acts as an adaptor to invoke business objects from the presentation tier | https://huggingface.co/datasets/fmars/wiki_stem |
A canonical model is a design pattern used to communicate between different data formats. Essentially: create a data model which is a superset of all the others ("canonical"), and create a "translator" module or layer to/from which all existing modules exchange data with other modules. The canonical model acts as a middleman | https://huggingface.co/datasets/fmars/wiki_stem |
Circuit breaker is a design pattern used in software development. It is used to detect failures and encapsulates the logic of preventing a failure from constantly recurring, during maintenance, temporary external system failure or unexpected system difficulties.
Common uses
Assume that an application connects to a database 100 times per second and the database fails | https://huggingface.co/datasets/fmars/wiki_stem |
In object-oriented programming, the command pattern is a behavioral design pattern in which an object is used to encapsulate all information needed to perform an action or trigger an event at a later time. This information includes the method name, the object that owns the method and values for the method parameters.
Four terms always associated with the command pattern are command, receiver, invoker and client | https://huggingface.co/datasets/fmars/wiki_stem |
Composite entity is a Java EE Software design pattern and it is used to model, represent, and manage a set of interrelated persistent objects rather than representing them as individual fine-grained entity beans, and also a composite entity bean represents a graph of objects.
Structure
There are a number of strategies to implement composite entity pattern. This pattern mainly composites of composite entity, coarse-grained object, and dependent objects | https://huggingface.co/datasets/fmars/wiki_stem |
In software engineering, the composite pattern is a partitioning design pattern. The composite pattern describes a group of objects that are treated the same way as a single instance of the same type of object. The intent of a composite is to "compose" objects into tree structures to represent part-whole hierarchies | https://huggingface.co/datasets/fmars/wiki_stem |
The composition filters model denotes a modular extension to the conventional object model. It provides a solution for a wide range of problems in the construction of large and complex applications. Most notably, one implementation of composition filters provides an abstraction layer for message-passing systems | https://huggingface.co/datasets/fmars/wiki_stem |
In software engineering, creational design patterns are design patterns that deal with object creation mechanisms, trying to create objects in a manner suitable to the situation. The basic form of object creation could result in design problems or in added complexity to the design. Creational design patterns solve this problem by somehow controlling this object creation | https://huggingface.co/datasets/fmars/wiki_stem |
The curiously recurring template pattern (CRTP) is an idiom, originally in C++, in which a class X derives from a class template instantiation using X itself as a template argument. More generally it is known as F-bound polymorphism, and it is a form of F-bounded quantification.
History
The technique was formalized in 1989 as "F-bounded quantification | https://huggingface.co/datasets/fmars/wiki_stem |
In software, a data access object (DAO) is a pattern that provides an abstract interface to some type of database or other persistence mechanism. By mapping application calls to the persistence layer, the DAO provides data operations without exposing database details. This isolation supports the single responsibility principle | https://huggingface.co/datasets/fmars/wiki_stem |
In software engineering, the data mapper pattern is an architectural pattern. It was named by Martin Fowler in his 2003 book Patterns of Enterprise Application Architecture. The interface of an object conforming to this pattern would include functions such as Create, Read, Update, and Delete, that operate on objects that represent domain entity types in a data store | https://huggingface.co/datasets/fmars/wiki_stem |
In the field of programming a data transfer object (DTO) is an object that carries data between processes. The motivation for its use is that communication between processes is usually done resorting to remote interfaces (e. g | https://huggingface.co/datasets/fmars/wiki_stem |
Data, context, and interaction (DCI) is a paradigm used in computer software to program systems of communicating objects. Its goals are:
To improve the readability of object-oriented code by giving system behavior first-class status;
To cleanly separate code for rapidly changing system behavior (what a system does) versus slowly changing domain knowledge (what a system is), instead of combining both in one class interface;
To help software developers reason about system-level state and behavior instead of only object state and behavior;
To support an object style of thinking that is close to programmers' mental models, rather than the class style of thinking that overshadowed object thinking early in the history of object-oriented programming languages. The paradigm separates the domain model (data) from use cases (context) and Roles that objects play (interaction) | https://huggingface.co/datasets/fmars/wiki_stem |
A debugging pattern describes a generic set of steps to rectify or correct a bug within a software system. It is a solution to a recurring problem that is related to a particular bug or type of bug in a specific context.
A bug pattern is a particular type of pattern | https://huggingface.co/datasets/fmars/wiki_stem |
In object-oriented programming, the decorator pattern is a design pattern that allows behavior to be added to an individual object, dynamically, without affecting the behavior of other objects from the same class. The decorator pattern is often useful for adhering to the Single Responsibility Principle, as it allows functionality to be divided between classes with unique areas of concern as well as to the Open-Closed Principle, by allowing the functionality of a class to be extended without being modified. Decorator use can be more efficient than subclassing, because an object's behavior can be augmented without defining an entirely new object | https://huggingface.co/datasets/fmars/wiki_stem |
In software engineering, the delegation pattern is an object-oriented design pattern that allows object composition to achieve the same code reuse as inheritance.
In delegation, an object handles a request by delegating to a second object (the delegate). The delegate is a helper object, but with the original context | https://huggingface.co/datasets/fmars/wiki_stem |
In software engineering, dependency injection is a programming technique in which an object or function receives other objects or functions that it requires, as opposed to creating them internally. Dependency injection aims to separate the concerns of constructing objects and using them, leading to loosely coupled programs. The pattern ensures that an object or function which wants to use a given service should not have to know how to construct those services | https://huggingface.co/datasets/fmars/wiki_stem |
In object-oriented design, the dependency inversion principle is a specific methodology for loosely coupled software modules. When following this principle, the conventional dependency relationships established from high-level, policy-setting modules to low-level, dependency modules are reversed, thus rendering high-level modules independent of the low-level module implementation details. The principle states:
By dictating that both high-level and low-level objects must depend on the same abstraction, this design principle inverts the way some people may think about object-oriented programming | https://huggingface.co/datasets/fmars/wiki_stem |
In software engineering, the blackboard pattern is a behavioral design pattern that provides a computational framework for the design and implementation of systems that integrate large and diverse specialized modules, and implement complex, non-deterministic control strategies. This pattern was identified by the members of the Hearsay-II project and first applied to speech recognition.
Structure
The blackboard model defines three main components:
blackboard—a structured global memory containing objects from the solution space
knowledge sources—specialized modules with their own representation
control component—selects, configures and executes modules | https://huggingface.co/datasets/fmars/wiki_stem |
The broker pattern is an architectural pattern that can be used to structure distributed software systems with decoupled components that interact by remote procedure calls. A broker component is responsible for coordinating communication, such as forwarding requests, as well as for transmitting results and exceptions.
Definition
The broker pattern is an architecture pattern that involves the use of an intermediary software entity called "broker" to facilitate communication between two or more software components | https://huggingface.co/datasets/fmars/wiki_stem |
In object-oriented design, the chain-of-responsibility pattern is a behavioral design pattern consisting of a source of command objects and a series of processing objects. Each processing object contains logic that defines the types of command objects that it can handle; the rest are passed to the next processing object in the chain. A mechanism also exists for adding new processing objects to the end of this chain | https://huggingface.co/datasets/fmars/wiki_stem |
Design Patterns: Elements of Reusable Object-Oriented Software (1994) is a software engineering book describing software design patterns. The book was written by Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides, with a foreword by Grady Booch. The book is divided into two parts, with the first two chapters exploring the capabilities and pitfalls of object-oriented programming, and the remaining chapters describing 23 classic software design patterns | https://huggingface.co/datasets/fmars/wiki_stem |
Differentiated service is a design pattern for business services and software, in which the service varies automatically according to the identity of the consumer and/or the context in which the service is used. Sometimes known as smart service or context-aware service.
Concept
Differentiated service is extensively covered in a few narrow technical areas, such as telecoms networks and internet (see Differentiated services) | https://huggingface.co/datasets/fmars/wiki_stem |
In object-oriented programming, the dispose pattern is a design pattern for resource management. In this pattern, a resource is held by an object, and released by calling a conventional method – usually called close, dispose, free, release depending on the language – which releases any resources the object is holding onto. Many programming languages offer language constructs to avoid having to call the dispose method explicitly in common situations | https://huggingface.co/datasets/fmars/wiki_stem |
In software engineering, double dispatch is a special form of multiple dispatch, and a mechanism that dispatches a function call to different concrete functions depending on the runtime types of two objects involved in the call. In most object-oriented systems, the concrete function that is called from a function call in the code depends on the dynamic type of a single object and therefore they are known as single dispatch calls, or simply virtual function calls.
Dan Ingalls first described how to use double dispatching in Smalltalk, calling it multiple polymorphism | https://huggingface.co/datasets/fmars/wiki_stem |
In software engineering, a double-chance function is a software design pattern with a strong application in cross-platform and scalable development.
Examples
Computer graphics
Consider a graphics API with functions to DrawPoint, DrawLine, and DrawSquare. It is easy to see that DrawLine can be implemented solely in terms of DrawPoint, and DrawSquare can in turn be implemented through four calls to DrawLine | https://huggingface.co/datasets/fmars/wiki_stem |
In software engineering, double-checked locking (also known as "double-checked locking optimization") is a software design pattern used to reduce the overhead of acquiring a lock by testing the locking criterion (the "lock hint") before acquiring the lock. Locking occurs only if the locking criterion check indicates that locking is required.
The original form of the pattern, appearing in Pattern Languages of Program Design 3, has data races, depending on the memory model in use, and it is hard to get right | https://huggingface.co/datasets/fmars/wiki_stem |
Enterprise Integration Patterns is a book by Gregor Hohpe and Bobby Woolf and describes 65 patterns for the use of enterprise application integration and message-oriented middleware in the form of a pattern language.
The integration (messaging) pattern language
The pattern language presented in the book consists of 65 patterns structured into 9 categories, which largely follow the flow of a message from one system to the next through channels, routing, and transformations. The book includes an icon-based pattern language, sometimes nicknamed "GregorGrams" after one of the authors | https://huggingface.co/datasets/fmars/wiki_stem |
Exception chaining, or exception wrapping, is an object-oriented programming technique of handling exceptions by re-throwing a caught exception after wrapping it inside a new exception. The original exception is saved as a property (such as cause) of the new exception. The idea is that a method should throw exceptions defined at the same abstraction level as the method itself, but without discarding information from the lower levels | https://huggingface.co/datasets/fmars/wiki_stem |
The facade pattern (also spelled façade) is a software-design pattern commonly used in object-oriented programming. Analogous to a facade in architecture, a facade is an object that serves as a front-facing interface masking more complex underlying or structural code. A facade can:
improve the readability and usability of a software library by masking interaction with more complex components behind a single (and often simplified) API
provide a context-specific interface to more generic functionality (complete with context-specific input validation)
serve as a launching point for a broader refactor of monolithic or tightly-coupled systems in favor of more loosely-coupled codeDevelopers often use the facade design pattern when a system is very complex or difficult to understand because the system has many interdependent classes or because its source code is unavailable | https://huggingface.co/datasets/fmars/wiki_stem |
In class-based programming, the factory method pattern is a creational pattern that uses factory methods to deal with the problem of creating objects without having to specify the exact class of the object that will be created. This is done by creating objects by calling a factory method—either specified in an interface and implemented by child classes, or implemented in a base class and optionally overridden by derived classes—rather than by calling a constructor.
Overview
The Factory Method
design pattern is one of the twenty-three well-known design patterns that describe how to solve recurring design problems to design flexible and reusable object-oriented software, that is, objects that are easier to implement, change, test, and reuse | https://huggingface.co/datasets/fmars/wiki_stem |
A filter is a computer program or subroutine to process a stream, producing another stream. While a single filter can be used individually, they are frequently strung together to form a pipeline.
Some operating systems such as Unix are rich with filter programs | https://huggingface.co/datasets/fmars/wiki_stem |
In software engineering, a fluent interface is an object-oriented API whose design relies extensively on method chaining. Its goal is to increase code legibility by creating a domain-specific language (DSL). The term was coined in 2005 by Eric Evans and Martin Fowler | https://huggingface.co/datasets/fmars/wiki_stem |
In computer programming, the flyweight software design pattern refers to an object that minimizes memory usage by sharing some of its data with other similar objects. The flyweight pattern is one of twenty-three well-known GoF design patterns. These patterns promote flexible object-oriented software design, which is easier to implement, change, test, and reuse | https://huggingface.co/datasets/fmars/wiki_stem |
The front controller software design pattern is listed in several pattern catalogs and is related to the design of web applications. It is "a controller that handles all requests for a website," which is a useful structure for web application developers to achieve flexibility and reuse without code redundancy.
Instruction
Front controllers are often used in web applications to implement workflows | https://huggingface.co/datasets/fmars/wiki_stem |
In functional programming, a functor is a design pattern inspired by the definition from category theory that allows one to apply a function to values inside a generic type without changing the structure of the generic type. In Haskell this idea can be captured in a type class:
This declaration says that any type of Functor must support a method fmap, which maps a function over the element(s) of the Functor.
Functors in Haskell should also obey functor laws, which state that the mapping operation preserves the identity function and composition of functions:
(where | https://huggingface.co/datasets/fmars/wiki_stem |
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 | https://huggingface.co/datasets/fmars/wiki_stem |
In concurrent programming, guarded suspension is a software design pattern for managing operations that require both a lock to be acquired and a precondition to be satisfied before the operation can be executed. The guarded suspension pattern is typically applied to method calls in object-oriented programs, and involves suspending the method call, and the calling thread, until the precondition (acting as a guard) is satisfied.
Usage
Because it is blocking, the guarded suspension pattern is generally only used when the developer knows that a method call will be suspended for a finite and reasonable period of time | https://huggingface.co/datasets/fmars/wiki_stem |
The Hillside Group is an educational nonprofit organization founded in August 1993 to help software developers analyze and document common development and design problems as software design patterns. The Hillside Group supports the patterns community through sponsorship of the Pattern Languages of Programs conferences.
History
In August 1993, Kent Beck and Grady Booch sponsored a mountain retreat in Colorado where a group converged on foundations for software patterns | https://huggingface.co/datasets/fmars/wiki_stem |
The inbox pattern and outbox pattern are two related patterns used by applications to persist data (usually in a database) to be used for operations with guaranteed delivery. The inbox and outbox concepts are used in the ActivityPub protocol and in email.
The inbox pattern
The application receives data which it persists to an inbox table in a database | https://huggingface.co/datasets/fmars/wiki_stem |
In software engineering, the initialization-on-demand holder (design pattern) idiom is a lazy-loaded singleton. In all versions of Java, the idiom enables a safe, highly concurrent lazy initialization of static fields with good performance.
The implementation of the idiom relies on the initialization phase of execution within the Java Virtual Machine (JVM) as specified by the Java Language Specification (JLS) | https://huggingface.co/datasets/fmars/wiki_stem |
Interaction design patterns are design patterns applied in the context human-computer interaction, describing common designs for graphical user interfaces.
A design pattern is a formal way of documenting a solution to a common design problem. The idea was introduced by the architect Christopher Alexander for use in urban planning and building architecture and has been adapted for various other disciplines, including teaching and pedagogy, development organization and process, and software architecture and design | https://huggingface.co/datasets/fmars/wiki_stem |
Intercepting Filter is a JavaEE pattern which creates pluggable filters to process common services in a standard manner without requiring changes to core request processing code. The filters intercept incoming requests and outgoing responses, allowing preprocessing and post-processing, and these filters can be added or removed unobtrusively without changing existing code. This pattern applies reusable processing transparently before and after the actual request execution by the front and page controllers | https://huggingface.co/datasets/fmars/wiki_stem |
In the field of software development, an interceptor pattern is a software design pattern that is used when software systems or frameworks want to offer a way to change, or augment, their usual processing cycle. For example, a (simplified) typical processing sequence for a web-server is to receive a URI from the browser, map it to a file on disk, open the file and send its contents to the browser. Any of these steps could be replaced or changed, e | https://huggingface.co/datasets/fmars/wiki_stem |
In computer programming, the interpreter pattern is a design pattern that specifies how to evaluate sentences in a language.
The basic idea is to have a class for each symbol (terminal or nonterminal) in a specialized computer language. The syntax tree of a sentence in the language is an instance of the composite pattern and is used to evaluate (interpret) the sentence for a client | https://huggingface.co/datasets/fmars/wiki_stem |
In software engineering, inversion of control (IoC) is a design pattern in which custom-written portions of a computer program receive the flow of control from a generic framework. The term "inversion" is historical: a software architecture with this design "inverts" control as compared to procedural programming. In procedural programming, the code that expresses the purpose of the program calls reusable libraries to take care of generic tasks, but with inversion of control, it is the framework that calls the custom (program) code | https://huggingface.co/datasets/fmars/wiki_stem |
In object-oriented programming, the iterator pattern is a design pattern in which an iterator is used to traverse a container and access the container's elements. The iterator pattern decouples algorithms from containers; in some cases, algorithms are necessarily container-specific and thus cannot be decoupled.
For example, the hypothetical algorithm SearchForElement can be implemented generally using a specified type of iterator rather than implementing it as a container-specific algorithm | https://huggingface.co/datasets/fmars/wiki_stem |
In computing based on the Java Platform, JavaBeans is a technology developed by Sun Microsystems and released in 1996, as part of JDK 1. 1.
The 'beans' of JavaBeans are classes that encapsulate one or more objects into a single standardized object (the bean) | https://huggingface.co/datasets/fmars/wiki_stem |
Join-patterns provides a way to write concurrent, parallel and distributed computer programs by message passing. Compared to the use of threads and locks, this is a high level programming model using communication constructs model to abstract the complexity of concurrent environment and to allow scalability. Its focus is on the execution of a chord between messages atomically consumed from a group of channels | https://huggingface.co/datasets/fmars/wiki_stem |
In the design of Java Web applications, there are two commonly used design models, referred to as Model 1 and Model 2.
In Model 1, a request is made to a JSP or servlet and then that JSP or servlet handles all responsibilities for the request, including processing the request, validating data, handling the business logic, and generating a response. The Model 1 architecture is commonly used in smaller, simple task applications due to its ease of development | https://huggingface.co/datasets/fmars/wiki_stem |
JSP Model 2 is a complex design pattern used in the design of Java Web applications which separates the display of content from the logic used to obtain and manipulate the content. Since Model 2 drives a separation between logic and display, it is usually associated with the model–view–controller (MVC) paradigm. While the exact form of the MVC "Model" was never specified by the Model 2 design, a number of publications recommend a formalized layer to contain MVC Model code | https://huggingface.co/datasets/fmars/wiki_stem |
In computer programming, lazy initialization is the tactic of delaying the creation of an object, the calculation of a value, or some other expensive process until the first time it is needed. It is a kind of lazy evaluation that refers specifically to the instantiation of objects or other resources.
This is typically accomplished by augmenting an accessor method (or property getter) to check whether a private member, acting as a cache, has already been initialized | https://huggingface.co/datasets/fmars/wiki_stem |
Lazy loading (also known as asynchronous loading) is a technique commonly used in computer programming and mostly in web design and development to defer initialization of an object until the point at which it is needed. It can contribute to efficiency in the program's operation if properly and appropriately used. This makes it ideal in use cases where network content is accessed and initialization times are to be kept at a minimum, such as in the case of web pages | https://huggingface.co/datasets/fmars/wiki_stem |
The Loader-Content-Handler-Handler, or "LCHH", is a web programming architecture that is closely modeled after the HTTP request-response cycle and the 3-tier web structure.
As its name suggests, LCHH defines four key implementation components:
The Loader is an ID'ed DIV container that identifies a partial update region for later content injection;
The Content that contains both static information and interactive elements, also known as "Triggers";
Client-side Handlers that process various trigger events, such as button clicks;
Server-side Handlers that respond to AJAX requests that are sent by the client-side handlers. Server-side handlers typically perform database CRUD operations before piggy-backing the updated content into the aforementioned Loader | https://huggingface.co/datasets/fmars/wiki_stem |
In computer science, a lock or mutex (from mutual exclusion) is a synchronization primitive: a mechanism that enforces limits on access to a resource when there are many threads of execution. A lock is designed to enforce a mutual exclusion concurrency control policy, and with a variety of possible methods there exists multiple unique implementations for different applications.
Types
Generally, locks are advisory locks, where each thread cooperates by acquiring the lock before accessing the corresponding data | https://huggingface.co/datasets/fmars/wiki_stem |
In the field of database design, a multi-model database is a database management system designed to support multiple data models against a single, integrated backend. In contrast, most database management systems are organized around a single data model that determines how data can be organized, stored, and manipulated. Document, graph, relational, and key–value models are examples of data models that may be supported by a multi-model database | https://huggingface.co/datasets/fmars/wiki_stem |
Necessary Condition Analysis (NCA) is a research approach and tool employed to discern "necessary conditions" within datasets. These indispensable conditions stand as pivotal determinants of particular outcomes, wherein the absence of such conditions ensures the absence of the intended result. Illustratively, the admission of a student into a Ph | https://huggingface.co/datasets/fmars/wiki_stem |
Negative testing is a method of testing an application or system that ensures that the plot of the application is according to the requirements and can handle the unwanted input and user behavior. Invalid data is inserted to compare the output against the given input. Negative testing is also known as failure testing or error path testing | https://huggingface.co/datasets/fmars/wiki_stem |
A NoSQL (originally referring to "non-SQL" or "non-relational") database provides a mechanism for storage and retrieval of data that is modeled in means other than the tabular relations used in relational databases. Such databases have existed since the late 1960s, but the name "NoSQL" was only coined in the early 21st century, triggered by the needs of Web 2. 0 companies | https://huggingface.co/datasets/fmars/wiki_stem |
The offset filtration (also called the "union-of-balls" or "union-of-disks" filtration) is a growing sequence of metric balls used to detect the size and scale of topological features of a data set. The offset filtration commonly arises in persistent homology and the field of topological data analysis. Utilizing a union of balls to approximate the shape of geometric objects was first suggested by Frosini in 1992 in the context of submanifolds of Euclidean space | https://huggingface.co/datasets/fmars/wiki_stem |
Open coding in grounded theory method is the analytic process by which concepts (codes) to the observed data and phenomenon are attached during qualitative data analysis. It is one of the 'procedures' for working with text as characterized by Strauss (1987) and Strauss and Corbin (1990). Open coding aims at developing substantial codes describing, naming or classifying the phenomenon under consideration | https://huggingface.co/datasets/fmars/wiki_stem |
Open data indices are indicators which assess and evaluates the general openness of an open government data portal. Open data indices not only show how open a data portal is, but also encourage citizens and government officials alike, to participate in their local open data communities, particularly in advocating for local open data and local open data policies.
There are two mainstream methodologies, which are Global Open Data Index and Open Data Barometer | https://huggingface.co/datasets/fmars/wiki_stem |
OPeNDAP is an acronym for "Open-source Project for a Network Data Access Protocol," an endeavor focused on enhancing the retrieval of remote, structured data through a Web-based architecture and a discipline-neutral Data Access Protocol (DAP). Widely used, especially in Earth science, the protocol is layered on HTTP, and its current specification is DAP4, though the previous DAP2 version remains broadly used. Developed and advanced (openly and collaboratively) by the non-profit OPeNDAP, Inc | https://huggingface.co/datasets/fmars/wiki_stem |
Operational analytical processing, or more popularly known as operational analytics, is a subset of data analytics that focuses on improving the operational nature of a business or entity.
The main characteristic that distinguishes operational analytics from other types of analytics is that it is analytics on the fly, which means that signals emanating from various parts of a business are processed in real-time to feed back into instant decision-making for the business. Some people refer to this as "continuous analytics," which is another way to emphasize the continuous digital feedback loop that can exist from one part of a business to its other parts | https://huggingface.co/datasets/fmars/wiki_stem |
A persistence module is a mathematical structure in persistent homology and topological data analysis that formally captures the persistence of topological features of an object across a range of scale parameters. A persistence module often consists of a collection of homology groups (or vector spaces if using field coefficients) corresponding to a filtration of topological spaces, and a collection of linear maps induced by the inclusions of the filtration. The concept of a persistence module was first introduced in 2005 as an application of graded modules over polynomial rings, thus importing well-developed algebraic ideas from classical commutative algebra theory to the setting of persistent homology | https://huggingface.co/datasets/fmars/wiki_stem |
In persistent homology, a persistent homology group is a multiscale analog of a homology group that captures information about the evolution of topological features across a filtration of spaces. While the ordinary homology group represents nontrivial homology classes of an individual topological space, the persistent homology group tracks only those classes that remain nontrivial across multiple parameters in the underlying filtration. Analogous to the ordinary Betti number, the ranks of the persistent homology groups are known as the persistent Betti numbers | https://huggingface.co/datasets/fmars/wiki_stem |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.