text
stringlengths 1
1k
| source
stringlengths 31
152
|
|---|---|
In computer programming, a directive or pragma (from "pragmatic") is a language construct that specifies how a compiler (or other translator) should process its input. Depending on the programming language, directives may or may not be part of the grammar of the language and may vary from compiler to compiler. They can be processed by a preprocessor to specify compiler behavior, or function as a form of in-band parameterization.
In some cases directives specify global behavior, while in other cases they only affect a local section, such as a block of programming code. In some cases, such as some C programs, directives are optional compiler hints and may be ignored, but normally they are prescriptive and must be followed. However, a directive does not perform any action in the language itself, but rather only a change in the behavior of the compiler.
This term could be used to refer to proprietary third-party tags and commands (or markup) embedded in code that result in additional execu
|
https://en.wikipedia.org/wiki/Directive_(programming)
|
) embedded in code that result in additional executable processing that extend the existing compiler, assembler and language constructs present in the development environment. The term "directive" is also applied in a variety of ways that are similar to the term command.
== The C preprocessor ==
In C and C++, the language supports a simple macro preprocessor. Source lines that should be handled by the preprocessor, such as #define and #include are referred to as preprocessor directives.
Syntactic constructs similar to C's preprocessor directives, such as C#'s #if, are also typically called "directives", although in these cases there may not be any real preprocessing phase involved.
All preprocessor commands, except for defined (when following a conditional directive), begin with a hash symbol (#). Until C++26, the keywords export, import and module were partially handled by the preprocessor.
== History ==
Directives date to JOVIAL.
COBOL has a COPY directive.
In ALGOL 68, directi
|
https://en.wikipedia.org/wiki/Directive_(programming)
|
COBOL has a COPY directive.
In ALGOL 68, directives are known as pragmats (from "pragmatic"), and denoted pragmat or pr; in newer languages, notably C, this has been abbreviated to "pragma" (no 't').
A common use of pragmats in ALGOL 68 is in specifying a stropping regime, meaning "how keywords are indicated". Various such directives follow, specifying the POINT, UPPER, RES (reserved), or quote regimes. Note the use of stropping for the pragmat keyword itself (abbreviated pr), either in the POINT or quote regimes:
Today directives are best known in the C language, of early 1970s vintage, and continued through the current C99 standard, where they are either instructions to the C preprocessor, or, in the form of #pragma, directives to the compiler itself. They are also used to some degree in more modern languages; see below.
== Other languages ==
In Ada, compiler directives are called pragmas (short for "pragmatic information").
In Common Lisp, directives are called declarations, an
|
https://en.wikipedia.org/wiki/Directive_(programming)
|
ommon Lisp, directives are called declarations, and are specified using the declare construct (also proclaim or declaim). With one exception, declarations are optional, and do not affect the semantics of the program. The one exception is special, which must be specified where appropriate.
In Turbo Pascal, directives are called significant comments, because in the language grammar they follow the same syntax as comments. In Turbo Pascal, a significant comment is a comment whose first character is a dollar sign and whose second character is a letter; for example, the equivalent of C's #include "file" directive is the significant comment {$I "file"}.
In Perl, the keyword "use", which imports modules, can also be used to specify directives, such as use strict; or use utf8;.
Haskell pragmas are specified using a specialized comment syntax, e.g. {-# INLINE foo #-}. It is also possible to use the C preprocessor in Haskell, by writing {-# LANGUAGE CPP #-}.
PHP uses the directive declare(strict
|
https://en.wikipedia.org/wiki/Directive_(programming)
|
AGE CPP #-}.
PHP uses the directive declare(strict_types=1).
In PL/I, directives begin with a Percent sign (%) and end with a semicolon (;), e.g., %INCLUDE foo;, %NOPRINT;, %PAGE;, %POP;, %SKIP;, the same as with preprocessor statements.
Python has two directives – from __future__ import feature (defined in PEP 236 -- Back to the __future__), which changes language features (and uses the existing module import syntax, as in Perl), and the coding directive (in a comment) to specify the encoding of a source code file (defined in PEP 263 -- Defining Python Source Code Encodings). A more general directive statement was proposed and rejected in PEP 244 -- The `directive' statement; these all date to 2001.
ECMAScript also adopts the use syntax for directives, with the difference that pragmas are declared as string literals (e.g. "use strict";, or "use asm";), rather than a function call.
In Visual Basic, the keyword "Option" is used for directives:
Option Explicit On|Off - When on disallows
|
https://en.wikipedia.org/wiki/Directive_(programming)
|
tives:
Option Explicit On|Off - When on disallows implicit declaration of variables at first use requiring explicit declaration beforehand.
Option Compare Binary - Results in string comparisons based on a sort order derived from the internal binary representations of the characters - e.g. for the English/European code page (ANSI 1252) A < B < E < Z < a < b < e < z < À < Ê < Ø < à < ê < ø. Affects intrinsic operators (e.g. =, <>, <, >), the Select Case block, and VB runtime library string functions (e.g. InStr).
Option Compare Text - Results in string comparisons based on a case-insensitive text sort order determined by your system's locale - e.g. for the English/European code page (ANSI 1252) (A=a) < (À = à) < (B=b) < (E=e) < (Ê = ê) < (Z=z) < (Ø = ø). Affects intrinsic operators (e.g. =, <>, <, >), the Select Case block, and VB runtime library string functions (e.g. InStr).
Option Strict On|Off - When on disallows:
typeless programming - where declarations which lack an explicit type
|
https://en.wikipedia.org/wiki/Directive_(programming)
|
- where declarations which lack an explicit type are implicitly typed as Object.
late-binding (i.e. dynamic dispatch to CLR, DLR, and COM objects) on values statically typed as Object.
implicit narrowing conversions - requiring all conversions to narrower types (e.g. from Long to Integer, Object to String, Control to TextBox) be explicit in code using conversion operators (e.g. CInt, DirectCast, CType).
Option Infer On|Off - When on enables the compiler to infer the type of local variables from their initializers.
In Ruby, interpreter directives are referred to as pragmas and are specified by top-of-file comments that follow a key: value notation. For example, coding: UTF-8 indicates that the file is encoded via the UTF-8 character encoding.
In C#, compiler directives are called pre-processing directives. C# does not technically handle these using a preprocessor, but rather directly in the code. There are a number of different compiler directives, which mostly align with those from C
|
https://en.wikipedia.org/wiki/Directive_(programming)
|
r directives, which mostly align with those from C and C++, including #pragma, which is specifically used to control compiler warnings and debugger checksums. C# also features some directives not used in C or C++, including #nullable and #region. C# also does not allow function-like macros, but does allow regular macros, for purposes such as conditional compilation.
The SQLite DBMS includes a PRAGMA directive that is used to introduce commands that are not compatible with other DBMS.
In Solidity, compiler directives are called pragmas, and are specified using the `pragma` keyword.
=== Assembly language ===
In assembly language, directives, also referred to as pseudo-operations or "pseudo-ops", generally specify such information as the target machine, mark separations between code sections, define and change assembly-time variables, define macros, designate conditional and repeated code, define reserved memory areas, and so on. Some, but not all, assemblers use a specific syntax to d
|
https://en.wikipedia.org/wiki/Directive_(programming)
|
but not all, assemblers use a specific syntax to differentiate pseudo-ops from instruction mnemonics, such as prefacing the pseudo-op with a period, such as the pseudo-op .END, which might direct the assembler to stop assembling code.
=== PL/SQL ===
Oracle Corporation's PL/SQL procedural language includes a set of compiler directives, known as "pragmas".
== See also ==
#pragma once – Preprocessor directive in C and C++
== Footnotes ==
== References ==
== External links ==
OpenMP Website
OpenACC Website
OpenHMPP Website
|
https://en.wikipedia.org/wiki/Directive_(programming)
|
A symbol in computer programming is a primitive data type whose instances have a human-readable form. Symbols can be used as identifiers. In some programming languages, they are called atoms. Uniqueness is enforced by holding them in a symbol table. The most common use of symbols by programmers is to perform language reflection (particularly for callbacks), and the most common indirectly is their use to create object linkages.
In the most trivial implementation, they are essentially named integers; e.g., the enumerated type in C language.
== Support ==
The following programming languages provide runtime support for symbols:
=== Julia ===
Symbols in Julia are interned strings used to represent identifiers in parsed Julia code(ASTs) and as names or labels to identify entities (for example as keys in a dictionary).
=== Lisp ===
A symbol in Lisp is unique in a namespace (or package in Common Lisp). Symbols can be tested for equality with the function EQ. Lisp programs can generate ne
|
https://en.wikipedia.org/wiki/Symbol_(programming)
|
ith the function EQ. Lisp programs can generate new symbols at runtime. When Lisp reads data that contains textual represented symbols, existing symbols are referenced. If a symbol is unknown, the Lisp reader creates a new symbol.
In Common Lisp, symbols have the following attributes: a name, a value, a function, a list of properties and a package.
In Common Lisp it is also possible that a symbol is not interned in a package. Such symbols can be printed, but when read back, a new symbol needs to be created. Since it is not interned, the original symbol can not be retrieved from a package.
In Common Lisp symbols may use any characters, including whitespace, such as spaces and newlines. If a symbol contains a whitespace character, it needs to be written as |this is a symbol|. Symbols can be used as identifiers for any kind of named programming constructs: variables, functions, macros, classes, types, goto tags and more.
Symbols can be interned in a package. Keyword symbols are self-evalu
|
https://en.wikipedia.org/wiki/Symbol_(programming)
|
erned in a package. Keyword symbols are self-evaluating, and interned in the package named KEYWORD.
==== Examples ====
The following is a simple external representation of a Common Lisp symbol:
Symbols can contain whitespace (and all other characters):
In Common Lisp symbols with a leading colon in their printed representations are keyword symbols. These are interned in the keyword package.
A printed representation of a symbol may include a package name. Two colons are written between the name of the package and the name of the symbol.
Packages can export symbols. Then only one colon is written between the name of the package and the name of the symbol.
Symbols, which are not interned in a package, can also be created and have a notation:
=== PostScript ===
In PostScript, references to name objects can be either literal or executable, influencing the behaviour of the interpreter when encountering them. The cvx and cvl operators can be used to convert between the two forms. Wh
|
https://en.wikipedia.org/wiki/Symbol_(programming)
|
s can be used to convert between the two forms. When names are constructed from strings by means of the cvn operator, the set of allowed characters is unrestricted.
=== Prolog ===
In Prolog, symbols (or atoms) are the main primitive data types, similar to numbers. The exact notation may differ in different Prolog dialects. However, it is always quite simple (no quotations or special beginning characters are necessary).
Contrary to many other languages, it is possible to give symbols a meaning by creating some Prolog facts and/or rules.
==== Examples ====
The following example demonstrates two facts (describing what father is) and one rule (describing the meaning of sibling). These three sentences use symbols (father, zeus, hermes, perseus and sibling) and some abstract variables (X, Y and Z). The mother relationship is omitted for clarity.
=== Ruby ===
In Ruby, symbols can be created with a literal form, or by converting a string.
They can be used as an identifier or an interned
|
https://en.wikipedia.org/wiki/Symbol_(programming)
|
They can be used as an identifier or an interned string. Two symbols with the same contents will always refer to the same object.
It is considered a best practice to use symbols as keys to an associative array in Ruby.
==== Examples ====
The following is a simple example of a symbol literal in Ruby:
Strings can be coerced into symbols, vice versa:
Symbols are objects of the Symbol class in Ruby:
Symbols are commonly used to dynamically send messages to (call methods on) objects:
Symbols as keys of an associative array:
=== Smalltalk ===
In Smalltalk, symbols can be created with a literal form, or by converting a string. They can be used as an identifier or an interned string. Two symbols with the same contents will always refer to the same object. In most Smalltalk implementations, selectors (method names) are implemented as symbols.
==== Examples ====
The following is a simple example of a symbol literal in Smalltalk:
Strings can be coerced into symbols, vice versa:
Symbo
|
https://en.wikipedia.org/wiki/Symbol_(programming)
|
gs can be coerced into symbols, vice versa:
Symbols conform to the symbol protocol, and their class is called Symbol in most implementations:
Symbols are commonly used to dynamically send messages to (call methods on) objects:
== References ==
|
https://en.wikipedia.org/wiki/Symbol_(programming)
|
A "Hello, World!" program is usually a simple computer program that emits (or displays) to the screen (often the console) a message similar to "Hello, World!". A small piece of code in most general-purpose programming languages, this program is used to illustrate a language's basic syntax. Such a program is often the first written by a student of a new programming language, but it can also be used as a sanity check to ensure that the computer software intended to compile or run source code is correctly installed, and that its operator understands how to use it.
== History ==
While several small test programs have existed since the development of programmable computers, the tradition of using the phrase "Hello, World!" as a test message was influenced by an example program in the 1978 book The C Programming Language, with likely earlier use in BCPL. The example program from the book prints "hello, world", and was inherited from a 1974 Bell Laboratories internal memorandum by Brian Ke
|
https://en.wikipedia.org/wiki/%22Hello,_World!%22_program
|
Bell Laboratories internal memorandum by Brian Kernighan, Programming in C: A Tutorial:
In the above example, the main( ) function defines where the program should start executing. The function body consists of a single statement, a call to the printf() function, which stands for "print formatted"; it outputs to the console whatever is passed to it as the parameter, in this case the string "hello, world".
The C-language version was preceded by Kernighan's own 1972 A Tutorial Introduction to the Language B, where the first known version of the program is found in an example used to illustrate external variables:
The program above prints hello, world! on the terminal, including a newline character. The phrase is divided into multiple variables because in B a character constant is limited to four ASCII characters. The previous example in the tutorial printed hi! on the terminal, and the phrase hello, world! was introduced as a slightly longer greeting that required several character co
|
https://en.wikipedia.org/wiki/%22Hello,_World!%22_program
|
longer greeting that required several character constants for its expression.
The Jargon File reports that "hello, world" instead originated in 1967 with the language BCPL. Outside computing, use of the exact phrase began over a decade prior; it was the catchphrase of New York radio disc jockey William B. Williams beginning in the 1950s.
== Variations ==
"Hello, World!" programs vary in complexity between different languages. In some languages, particularly scripting languages, the "Hello, World!" program can be written as one statement, while in others (more so many low-level languages) many more statements can be required. For example, in Python, to print the string Hello, World! followed by a newline, one only needs to write print("Hello, World!"). In contrast, the equivalent code in C++ requires the import of the input/output (I/O) software library, the manual declaration of an entry point, and the explicit instruction that the output string should be sent to the standard output
|
https://en.wikipedia.org/wiki/%22Hello,_World!%22_program
|
utput string should be sent to the standard output stream.
The phrase "Hello, World!" has seen various deviations in casing and punctuation, such as "hello world" which lacks the capitalization of the leading H and W, and the presence of the comma or exclamation mark. Some devices limit the format to specific variations, such as all-capitalized versions on systems that support only capital letters, while some esoteric programming languages may have to print a slightly modified string. Other human languages have been used as the output; for example, a tutorial for the Go language emitted both English and Chinese or Japanese characters, demonstrating the language's built-in Unicode support. Another notable example is the Rust language, whose management system automatically inserts a "Hello, World" program when creating new projects.
Some languages change the function of the "Hello, World!" program while maintaining the spirit of demonstrating a simple example. Functional programming la
|
https://en.wikipedia.org/wiki/%22Hello,_World!%22_program
|
rating a simple example. Functional programming languages, such as Lisp, ML, and Haskell, tend to substitute a factorial program for "Hello, World!", as functional programming emphasizes recursive techniques, whereas the original examples emphasize I/O, which violates the spirit of pure functional programming by producing side effects. Languages otherwise able to print "Hello, World!" (assembly language, C, VHDL) may also be used in embedded systems, where text output is either difficult (requiring added components or communication with another computer) or nonexistent. For devices such as microcontrollers, field-programmable gate arrays, and complex programmable logic devices (CPLDs), "Hello, World!" may thus be substituted with a blinking light-emitting diode (LED), which demonstrates timing and interaction between components.
The Debian and Ubuntu Linux distributions provide the "Hello, World!" program through their software package manager systems, which can be invoked with the com
|
https://en.wikipedia.org/wiki/%22Hello,_World!%22_program
|
manager systems, which can be invoked with the command hello. It serves as a sanity check and a simple example of installing a software package. For developers, it provides an example of creating a .deb package, either traditionally or using debhelper, and the version of hello used, GNU Hello, serves as an example of writing a GNU program.
Variations of the "Hello, World!" program that produce a graphical output (as opposed to text output) have also been shown. Sun demonstrated a "Hello, World!" program in Java based on scalable vector graphics, and the XL programming language features a spinning Earth "Hello, World!" using 3D computer graphics. Mark Guzdial and Elliot Soloway have suggested that the "hello, world" test message may be outdated now that graphics and sound can be manipulated as easily as text.
In computer graphics, rendering a triangle – called "Hello Triangle" – is sometimes used as an introductory example for graphics libraries.
== Time to Hello World ==
"Time to hel
|
https://en.wikipedia.org/wiki/%22Hello,_World!%22_program
|
ibraries.
== Time to Hello World ==
"Time to hello world" (TTHW) is the time it takes to author a "Hello, World!" program in a given programming language. This is one measure of a programming language's ease of use. Since the program is meant as an introduction for people unfamiliar with the language, a more complex "Hello, World!" program may indicate that the programming language is less approachable. For instance, the first publicly known "Hello, World!" program in Malbolge (which actually output "HEllO WORld") took two years to be announced, and it was produced not by a human but by a code generator written in Common Lisp (see § Variations, above).
The concept has been extended beyond programming languages to APIs, as a measure of how simple it is for a new developer to get a basic example working; a shorter time indicates an easier API for developers to adopt.
== Wikipedia articles containing "Hello, World!" programs ==
== See also ==
"99 Bottles of Beer" as used in compute
|
https://en.wikipedia.org/wiki/%22Hello,_World!%22_program
|
e also ==
"99 Bottles of Beer" as used in computer science
Bad Apple!! § Use of video as a graphical and audio test (graphic equivalent to "Hello, World!" for old hardware)
Foobar
Java Pet Store
Just another Perl hacker
Outline of computer science
TPK algorithm
Coding
== References ==
== External links ==
The Hello World Collection
"Hello world/Text". Rosetta Code. 23 May 2024.
"GitHub – leachim6/hello-world: Hello world in every computer language. Thanks to everyone who contributes to this, make sure to see CONTRIBUTING.md for contribution instructions!". GitHub. 30 October 2021.
"Unsung Heroes of IT: Part One: Brian Kernighan". TheUnsungHeroesOfIT.com. Archived from the original on 26 March 2016. Retrieved 23 August 2014.
|
https://en.wikipedia.org/wiki/%22Hello,_World!%22_program
|
Probabilistic programming (PP) is a programming paradigm based on the declarative specification of probabilistic models, for which inference is performed automatically. Probabilistic programming attempts to unify probabilistic modeling and traditional general purpose programming in order to make the former easier and more widely applicable. It can be used to create systems that help make decisions in the face of uncertainty. Programming languages following the probabilistic programming paradigm are referred to as "probabilistic programming languages" (PPLs).
== Applications ==
Probabilistic reasoning has been used for a wide variety of tasks such as predicting stock prices, recommending movies, diagnosing computers, detecting cyber intrusions and image detection. However, until recently (partially due to limited computing power), probabilistic programming was limited in scope, and most inference algorithms had to be written manually for each task.
Nevertheless, in 2015, a 50-line pro
|
https://en.wikipedia.org/wiki/Probabilistic_programming
|
or each task.
Nevertheless, in 2015, a 50-line probabilistic computer vision program was used to generate 3D models of human faces based on 2D images of those faces. The program used inverse graphics as the basis of its inference method, and was built using the Picture package in Julia. This made possible "in 50 lines of code what used to take thousands".
The Gen probabilistic programming library (also written in Julia) has been applied to vision and robotics tasks.
More recently, the probabilistic programming system Turing.jl has been applied in various pharmaceutical and economics applications.
Probabilistic programming in Julia has also been combined with differentiable programming by combining the Julia package Zygote.jl with Turing.jl.
Probabilistic programming languages are also commonly used in Bayesian cognitive science to develop and evaluate models of cognition.
== Probabilistic programming languages ==
PPLs often extend from a basic language. For instance, Turing.jl is b
|
https://en.wikipedia.org/wiki/Probabilistic_programming
|
rom a basic language. For instance, Turing.jl is based on Julia, Infer.NET is based on .NET Framework, while PRISM extends from Prolog. However, some PPLs, such as WinBUGS, offer a self-contained language that maps closely to the mathematical representation of the statistical models, with no obvious origin in another programming language.
The language for WinBUGS was implemented to perform Bayesian computation using Gibbs Sampling and related algorithms. Although implemented in a relatively unknown programming language (Component Pascal), this language permits Bayesian inference for a wide variety of statistical models using a flexible computational approach. The same BUGS language may be used to specify Bayesian models for inference via different computational choices ("samplers") and conventions or defaults, using a standalone program WinBUGS (or related R packages, rbugs and r2winbugs) and JAGS (Just Another Gibbs Sampler, another standalone program with related R packages includin
|
https://en.wikipedia.org/wiki/Probabilistic_programming
|
tandalone program with related R packages including rjags, R2jags, and runjags). More recently, other languages to support Bayesian model specification and inference allow different or more efficient choices for the underlying Bayesian computation, and are accessible from the R data analysis and programming environment, e.g.: Stan, NIMBLE and NUTS. The influence of the BUGS language is evident in these later languages, which even use the same syntax for some aspects of model specification.
Several PPLs are in active development, including some in beta test. Two popular tools are Stan and PyMC.
=== Relational ===
A probabilistic relational programming language (PRPL) is a PPL specially designed to describe and infer with probabilistic relational models (PRMs).
A PRM is usually developed with a set of algorithms for reducing, inference about and discovery of concerned distributions, which are embedded into the corresponding PRPL.
=== Probabilistic logic programming ===
Probabilistic
|
https://en.wikipedia.org/wiki/Probabilistic_programming
|
Probabilistic logic programming ===
Probabilistic logic programming is a programming paradigm that extends logic programming with probabilities.
Most approaches to probabilistic logic programming are based on the distribution semantics, which splits a program into a set of probabilistic facts and a logic program. It defines a probability distribution on interpretations of the Herbrand universe of the program.
=== List of probabilistic programming languages ===
This list summarises the variety of PPLs that are currently available, and clarifies their origins.
== Difficulty ==
Reasoning about variables as probability distributions causes difficulties for novice programmers, but these difficulties can be addressed through use of Bayesian network visualizations and graphs of variable distributions embedded within the source code editor.
As many PPLs rely on the specification of priors on the variables of interest, specifying informed priors is often difficult for novices. In some ca
|
https://en.wikipedia.org/wiki/Probabilistic_programming
|
priors is often difficult for novices. In some cases, libraries such as PyMC provide automated methods to find the parameterization of informed priors.
== See also ==
Statistical relational learning
Inductive programming
Bayesian programming
Plate notation
== Notes ==
== External links ==
Foundations of Probabilistic Programming
List of Probabilistic Model Mini Language Toolkits
|
https://en.wikipedia.org/wiki/Probabilistic_programming
|
Offensive programming is a name used for the branch of defensive programming that expressly departs from defensive principles when dealing with errors resulting from software bugs. Although the name is a reaction to extreme interpretations of defensive programming, the two are not fundamentally in conflict. Rather, offensive programming adds an explicit priority of not tolerating errors in wrong places: the point where it departs from extreme interpretations of defensive programming is in preferring the presence of errors from within the program's line of defense to be blatantly obvious over the hypothetical safety benefit of tolerating them. This preference is also what justifies using assertions.
== Distinguishing errors ==
The premise for offensive programming is to distinguish between expectable errors, coming from outside the program's line of defense, however improbable, versus preventable internal errors that shall not happen if all its software components behave as expected.
|
https://en.wikipedia.org/wiki/Offensive_programming
|
f all its software components behave as expected.
Contrasting examples:
== Bug detection strategies ==
Offensive programming is concerned with failing, so to disprove the programmer's assumptions. Producing an error message may be a secondary goal.
Strategies:
No unnecessary checks: Trusting that other software components behave as specified, so to not paper over any unknown problem, is the basic principle. In particular, some errors may already be guaranteed to crash the program (depending on programming language or running environment), for example dereferencing a null pointer. As such, null pointer checks are unnecessary for the purpose of stopping the program (but can be used to print error messages).
Assertions – checks that can be disabled – are the preferred way to check things that should be unnecessary to check, such as design contracts between software components.
Remove fallback code (limp mode) and fallback data (default values): These can hide defects in the main implem
|
https://en.wikipedia.org/wiki/Offensive_programming
|
values): These can hide defects in the main implementation, or, from the user point of view, hide the fact that the software is working suboptimally. Special attention to unimplemented parts may be needed as part of factory acceptance testing, as yet unimplemented code is at no stage of test driven development discoverable by failing unit tests.
Remove shortcut code (see the strategy pattern): A simplified code path may hide bugs in a more generic code path if the generic code almost never gets to run. Since the two are supposed to produce the same result, the simplified one can be eliminated.
== See also ==
Fail-fast system
== References ==
|
https://en.wikipedia.org/wiki/Offensive_programming
|
Neuro-linguistic programming (NLP) is a pseudoscientific approach to communication, personal development, and psychotherapy that first appeared in Richard Bandler and John Grinder's book The Structure of Magic I (1975). NLP asserts a connection between neurological processes, language, and acquired behavioral patterns, and that these can be changed to achieve specific goals in life. According to Bandler and Grinder, NLP can treat problems such as phobias, depression, tic disorders, psychosomatic illnesses, near-sightedness, allergy, the common cold, and learning disorders, often in a single session. They also say that NLP can model the skills of exceptional people, allowing anyone to acquire them.
NLP has been adopted by some hypnotherapists as well as by companies that run seminars marketed as leadership training to businesses and government agencies.
No scientific evidence supports the claims made by NLP advocates, and it has been called a pseudoscience. Scientific reviews have shown
|
https://en.wikipedia.org/wiki/Neuro-linguistic_programming
|
led a pseudoscience. Scientific reviews have shown that NLP is based on outdated metaphors of the brain's inner workings that are inconsistent with current neurological theory, and that NLP contains numerous factual errors. Reviews also found that research that favored NLP contained significant methodological flaws, and that three times as many studies of a much higher quality failed to reproduce the claims made by Bandler, Grinder, and other NLP practitioners.
== Early development ==
According to Bandler and Grinder, NLP consists of a methodology termed modeling, plus a set of techniques that they derived from its initial applications. They derived many of the fundamental techniques from the work of Virginia Satir, Milton Erickson and Fritz Perls. Bandler and Grinder also drew upon the theories of Gregory Bateson, and Noam Chomsky (particularly transformational grammar).
Bandler and Grinder say that their methodology can codify the structure inherent to the therapeutic "magic" as pe
|
https://en.wikipedia.org/wiki/Neuro-linguistic_programming
|
tructure inherent to the therapeutic "magic" as performed in therapy by Perls, Satir and Erickson, and indeed inherent to any complex human activity. From that codification, they say, the structure and its activity can be learned by others. Their 1975 book, The Structure of Magic I: A Book about Language and Therapy, is intended to be a codification of the therapeutic techniques of Perls and Satir.
Bandler and Grinder say that they used their own process of modeling to model Virginia Satir so they could produce what they termed the Meta-Model, a model for gathering information and challenging a client's language and underlying thinking. They say that by challenging linguistic distortions, specifying generalizations, and recovering deleted information in the client's statements, the transformational grammar concept of surface structure yields a more complete representation of the underlying deep structure and therefore has therapeutic benefit. Also derived from Satir were anchoring, fut
|
https://en.wikipedia.org/wiki/Neuro-linguistic_programming
|
nefit. Also derived from Satir were anchoring, future pacing and representational systems.
In contrast, the Milton-Model—a model of the purportedly hypnotic language of Milton Erickson—was described by Bandler and Grinder as "artfully vague" and metaphoric. The Milton-Model is used in combination with the Meta-Model as a softener, to induce "trance" and to deliver indirect therapeutic suggestion.
Psychologist Jean Mercer writes that Chomsky's theories "appear to be irrelevant" to NLP. Linguist Karen Stollznow describes Bandler's and Grinder's reference to such experts as namedropping. Other than Satir, the people they cite as influences did not collaborate with Bandler or Grinder. Chomsky himself has no association with NLP, with his work being theoretical in nature and having no therapeutic element. Stollznow writes, "[o]ther than borrowing terminology, NLP does not bear authentic resemblance to any of Chomsky's theories or philosophies—linguistic, cognitive or political."
According t
|
https://en.wikipedia.org/wiki/Neuro-linguistic_programming
|
s—linguistic, cognitive or political."
According to André Muller Weitzenhoffer, a researcher in the field of hypnosis, "the major weakness of Bandler and Grinder's linguistic analysis is that so much of it is built upon untested hypotheses and is supported by totally inadequate data." Weitzenhoffer adds that Bandler and Grinder misuse formal logic and mathematics, redefine or misunderstand terms from the linguistics lexicon (e.g., nominalization), create a scientific façade by needlessly complicating Ericksonian concepts with unfounded claims, make factual errors, and disregard or confuse concepts central to the Ericksonian approach.
More recently, Bandler has stated, "NLP is based on finding out what works and formalizing it. In order to formalize patterns I utilized everything from linguistics to holography ... The models that constitute NLP are all formal models based on mathematical, logical principles such as predicate calculus and the mathematical equations underlying holography.
|
https://en.wikipedia.org/wiki/Neuro-linguistic_programming
|
the mathematical equations underlying holography." There is no mention of the mathematics of holography nor of holography in general in Spitzer's, or Grinder's account of the development of NLP.
On the matter of the development of NLP, Grinder recollects:
My memories about what we thought at the time of discovery (with respect to the classic code we developed—that is, the years 1973 through 1978) are that we were quite explicit that we were out to overthrow a paradigm and that, for example, I, for one, found it very useful to plan this campaign using in part as a guide the excellent work of Thomas Kuhn (The Structure of Scientific Revolutions) in which he detailed some of the conditions which historically have obtained in the midst of paradigm shifts. For example, I believe it was very useful that neither one of us were qualified in the field we first went after—psychology and in particular, its therapeutic application; this being one of the conditions which Kuhn identified in his hi
|
https://en.wikipedia.org/wiki/Neuro-linguistic_programming
|
of the conditions which Kuhn identified in his historical study of paradigm shifts.
The philosopher Robert Todd Carroll responded that Grinder has not understood Kuhn's text on the history and philosophy of science, The Structure of Scientific Revolutions. Carroll replies: (a) individual scientists never have nor are they ever able to create paradigm shifts volitionally and Kuhn does not suggest otherwise; (b) Kuhn's text does not contain the idea that being unqualified in a field of science is a prerequisite to producing a result that necessitates a paradigm shift in that field and (c) The Structure of Scientific Revolutions is foremost a work of history and not an instructive text on creating paradigm shifts and such a text is not possible—extraordinary discovery is not a formulaic procedure. Carroll explains that a paradigm shift is not a planned activity, rather it is an outcome of scientific effort within the dominant paradigm that produces data that cannot be adequately accounte
|
https://en.wikipedia.org/wiki/Neuro-linguistic_programming
|
t produces data that cannot be adequately accounted for within the current paradigm—hence a paradigm shift, i.e. the adoption of a new paradigm. In developing NLP, Bandler and Grinder were not responding to a paradigmatic crisis in psychology nor did they produce any data that caused a paradigmatic crisis in psychology. There is no sense in which Bandler and Grinder caused or participated in a paradigm shift. "What did Grinder and Bandler do that makes it impossible to continue doing psychology ... without accepting their ideas? Nothing," argues Carroll.
=== Commercialization and evaluation ===
By the late 1970s, the human potential movement had developed into an industry and provided a market for some NLP ideas. At the center of this growth was the Esalen Institute at Big Sur, California. Perls had led numerous Gestalt therapy seminars at Esalen. Satir was an early leader and Bateson was a guest teacher. Bandler and Grinder have said that in addition to being a therapeutic method, N
|
https://en.wikipedia.org/wiki/Neuro-linguistic_programming
|
that in addition to being a therapeutic method, NLP was also a study of communication and began marketing it as a business tool, writing that, "if any human being can do anything, so can you." After 150 students paid $1,000 each for a ten-day workshop in Santa Cruz, California, Bandler and Grinder gave up academic writing and started producing popular books from seminar transcripts, such as Frogs into Princes, which sold more than 270,000 copies. According to court documents relating to an intellectual property dispute between Bandler and Grinder, Bandler made more than $800,000 in 1980 from workshop and book sales.
A community of psychotherapists and students began to form around Bandler and Grinder's initial works, leading to the growth and spread of NLP as a theory and practice. For example, Tony Robbins trained with Grinder and utilized a few ideas from NLP as part of his own self-help and motivational speaking programmes. Bandler led several unsuccessful efforts to exclude other
|
https://en.wikipedia.org/wiki/Neuro-linguistic_programming
|
led several unsuccessful efforts to exclude other parties from using NLP. Meanwhile, the rising number of practitioners and theorists led NLP to become even less uniform than it was at its foundation. Prior to the decline of NLP, scientific researchers began testing its theoretical underpinnings empirically, with research indicating a lack of empirical support for NLP's essential theories. The 1990s were characterized by fewer scientific studies evaluating the methods of NLP than the previous decade. Tomasz Witkowski attributes this to a declining interest in the debate as the result of a lack of empirical support for NLP from its proponents.
== Main components and core concepts ==
NLP can be understood in terms of three broad components: subjectivity, consciousness, and learning.
According to Bandler and Grinder, people experience the world subjectively, creating internal representations of their experiences. These representations involve the five senses and language. In other words
|
https://en.wikipedia.org/wiki/Neuro-linguistic_programming
|
volve the five senses and language. In other words, our conscious experiences take the form of sights, sounds, feelings, smells, and tastes. When we imagine something, recall an event, or think about the future, we utilize these same sensory systems within our minds Furthermore it is stated that these subjective representations of experience have a discernible structure, a pattern.
Bandler and Grinder assert that behavior (both our own and others') can be understood through these sensory-based internal representations. Behavior here includes verbal and non-verbal communication, as well as effective or adaptive behaviors and less helpful or "pathological" ones. They also assert that behavior in both the self and other people can be modified by manipulating these sense-based subjective representations.
NLP posits that consciousness can be divided into conscious and unconscious components. The part of our internal representations operating outside our direct awareness is referred to as th
|
https://en.wikipedia.org/wiki/Neuro-linguistic_programming
|
outside our direct awareness is referred to as the "unconscious mind".
Finally, NLP uses a method of learning called "modeling", designed to replicate expertise in any field. According to Bandler and Grinder, by analyzing the sequence of sensory and linguistic representations used by an expert while performing a skill, it's possible to create a mental model that can be learned by others.
== Techniques or set of practices ==
According to one study by Steinbach, a classic interaction in NLP can be understood in terms of several major stages including establishing rapport, gleaning information about a problem mental state and desired goals, using specific tools and techniques to make interventions, and integrating proposed changes into the client's life. The entire process is guided by the non-verbal responses of the client. The first is the act of establishing and maintaining rapport between the practitioner and the client which is achieved through pacing and leading the verbal (e.g.
|
https://en.wikipedia.org/wiki/Neuro-linguistic_programming
|
hieved through pacing and leading the verbal (e.g., sensory predicates and keywords) and non-verbal behavior (e.g., matching and mirroring non-verbal behavior, or responding to eye movements) of the client.
Once rapport is established, the practitioner may gather information about the client's present state as well as help the client define a desired state or goal for the interaction. The practitioner pays attention to the verbal and non-verbal responses as the client defines the present state and desired state and any resources that may be required to bridge the gap. The client is typically encouraged to consider the consequences of the desired outcome, and how they may affect his or her personal or professional life and relationships, taking into account any positive intentions of any problems that may arise. The practitioner thereafter assists the client in achieving the desired outcomes by using certain tools and techniques to change internal representations and responses to stimul
|
https://en.wikipedia.org/wiki/Neuro-linguistic_programming
|
e internal representations and responses to stimuli in the world. Finally, the practitioner helps the client to mentally rehearse and integrate the changes into his or her life. For example, the client may be asked to envision what it is like having already achieved the outcome.
According to Stollznow, "NLP also involves fringe discourse analysis and 'practical' guidelines for 'improved' communication. For example, one text asserts 'when you adopt the "but" word, people will remember what you said afterwards. With the "and" word, people remember what you said before and after.'"
== Applications ==
=== Alternative medicine ===
NLP has been promoted as being able to treat a variety of diseases including Parkinson's disease, HIV/AIDS and cancer. Such claims have no supporting medical evidence. People who use NLP as a form of treatment risk serious adverse health consequences as it can delay the provision of effective medical care.
=== Psychotherapeutic ===
Early books about NLP had
|
https://en.wikipedia.org/wiki/Neuro-linguistic_programming
|
= Psychotherapeutic ===
Early books about NLP had a psychotherapeutic focus given that the early models were psychotherapists. As an approach to psychotherapy, NLP shares similar core assumptions and foundations in common with some contemporary brief and systemic practices, such as solution focused brief therapy. NLP has also been acknowledged as having influenced these practices with its reframing techniques which seeks to achieve behavior change by shifting its context or meaning, for example, by finding the positive connotation of a thought or behavior.
The two main therapeutic uses of NLP are, firstly, as an adjunct by therapists practicing in other therapeutic disciplines and, secondly, as a specific therapy called Neurolinguistic Psychotherapy.
According to Stollznow, "Bandler and Grinder's infamous Frogs into Princes and their other books boast that NLP is a cure-all that treats a broad range of physical and mental conditions and learning difficulties, including epilepsy, myopia
|
https://en.wikipedia.org/wiki/Neuro-linguistic_programming
|
learning difficulties, including epilepsy, myopia and dyslexia. With its promises to cure schizophrenia, depression and Post Traumatic Stress Disorder, and its dismissal of psychiatric illnesses as psychosomatic, NLP shares similarities with Scientology and the Citizens Commission on Human Rights (CCHR)." A systematic review of experimental studies by Sturt et al. (2012) concluded that "there is little evidence that NLP interventions improve health-related outcomes." In his review of NLP, Stephen Briers writes, "NLP is not really a cohesive therapy but a ragbag of different techniques without a particularly clear theoretical basis ... [and its] evidence base is virtually non-existent." Eisner writes, "NLP appears to be a superficial and gimmicky approach to dealing with mental health problems. Unfortunately, NLP appears to be the first in a long line of mass marketing seminars that purport to virtually cure any mental disorder ... it appears that NLP has no empirical or scientific sup
|
https://en.wikipedia.org/wiki/Neuro-linguistic_programming
|
ppears that NLP has no empirical or scientific support as to the underlying tenets of its theory or clinical effectiveness. What remains is a mass-marketed serving of psychopablum."
André Muller Weitzenhoffer—a friend and peer of Milton Erickson—wrote, "Has NLP really abstracted and explicated the essence of successful therapy and provided everyone with the means to be another Whittaker, Virginia Satir, or Erickson? ... [NLP's] failure to do this is evident because today there is no multitude of their equals, not even another Whittaker, Virginia Satir, or Erickson. Ten years should have been sufficient time for this to happen. In this light, I cannot take NLP seriously ... [NLP's] contributions to our understanding and use of Ericksonian techniques are equally dubious. Patterns I and II are poorly written works that were an overambitious, pretentious effort to reduce hypnotism to a magic of words."
Clinical psychologist Stephen Briers questions the value of the NLP maxim—a presuppositi
|
https://en.wikipedia.org/wiki/Neuro-linguistic_programming
|
uestions the value of the NLP maxim—a presupposition in NLP jargon—"there is no failure, only feedback". Briers argues that the denial of the existence of failure diminishes its instructive value. He offers Walt Disney, Isaac Newton and J.K. Rowling as three examples of unambiguous acknowledged personal failure that served as an impetus to great success. According to Briers, it was "the crash-and-burn type of failure, not the sanitised NLP Failure Lite, i.e. the failure-that-isn't really-failure sort of failure" that propelled these individuals to success. Briers contends that adherence to the maxim leads to self-deprecation. According to Briers, personal endeavour is a product of invested values and aspirations and the dismissal of personally significant failure as mere feedback effectively denigrates what one values. Briers writes, "Sometimes we need to accept and mourn the death of our dreams, not just casually dismiss them as inconsequential." Briers also contends that the NLP maxi
|
https://en.wikipedia.org/wiki/Neuro-linguistic_programming
|
equential." Briers also contends that the NLP maxim is narcissistic, self-centered and divorced from notions of moral responsibility.
=== Other uses ===
Although the original core techniques of NLP were therapeutic in orientation their generic nature enabled them to be applied to other fields. These applications include persuasion, sales, negotiation, management training, sports, teaching, coaching, team building, public speaking, and in the process of hiring employees.
== Scientific criticism ==
In the early 1980s, NLP was advertised as an important advance in psychotherapy and counseling, and attracted some interest in counseling research and clinical psychology. However, as controlled trials failed to show any benefit from NLP and its advocates made increasingly dubious claims, scientific interest in NLP faded.
Numerous literature reviews and meta-analyses have failed to show evidence for NLP's assumptions or effectiveness as a therapeutic method. While some NLP practitioners ha
|
https://en.wikipedia.org/wiki/Neuro-linguistic_programming
|
herapeutic method. While some NLP practitioners have argued that the lack of empirical support is due to insufficient research which tests NLP, the consensus scientific opinion is that NLP is pseudoscience and that attempts to dismiss the research findings based on these arguments "[constitute]s an admission that NLP does not have an evidence base and that NLP practitioners are seeking a post-hoc credibility."
Surveys in the academic community have shown NLP to be widely discredited among scientists. Among the reasons for considering NLP a pseudoscience are that evidence in favor of it is limited to anecdotes and personal testimony that it is not informed by scientific understanding of neuroscience and linguistics, and that the name "neuro-linguistic programming" uses jargon words to impress readers and obfuscate ideas, whereas NLP itself does not relate any phenomena to neural structures and has nothing in common with linguistics or programming. In education, NLP has been used as a ke
|
https://en.wikipedia.org/wiki/Neuro-linguistic_programming
|
ogramming. In education, NLP has been used as a key example of pseudoscience.
== As a quasi-religion ==
Sociologists and anthropologists have categorized NLP as a quasi-religion belonging to the New Age and/or Human Potential Movements.
Medical anthropologist Jean M. Langford categorizes NLP as a form of folk magic; that is to say, a practice with symbolic efficacy—as opposed to physical efficacy—that is able to effect change through nonspecific effects (e.g., placebo). To Langford, NLP is akin to a syncretic folk religion "that attempts to wed the magic of folk practice to the science of professional medicine".
Bandler and Grinder were influenced by the shamanism described in the books of Carlos Castaneda. Concepts like "double induction" and "stopping the world", central to NLP modeling, were incorporated from these influences.
Some theorists characterize NLP as a type of "psycho-shamanism", and its focus on modeling has been compared to ritual practices in certain syncretic religi
|
https://en.wikipedia.org/wiki/Neuro-linguistic_programming
|
ed to ritual practices in certain syncretic religions. The emphasis on lineage from an NLP guru has also been likened to similar concepts in some Eastern religions. Aupers, Houtman, and Bovbjerg identify NLP as a New Age "psycho-religion". Bovbjerg argues that New Age movements center on a transcendent "other". While monotheistic religions seek communion with a divine being, this focus shifts inward in these movements, with the "other" becoming the unconscious self. Bovbjerg posits that this emphasis on the unconscious and its hidden potential underlies NLP techniques promoting self-perfection through ongoing transformation.
Bovbjerg's secular critique echoes the conservative Christian perspective, as exemplified by David Jeremiah. He argues that NLP's emphasis on self-transformation and internal power conflicts with the Christian belief in salvation through divine grace.
== Legal disputes ==
=== Founding, initial disputes, and settlement (1979–1981) ===
In 1979, Richard Bandler an
|
https://en.wikipedia.org/wiki/Neuro-linguistic_programming
|
lement (1979–1981) ===
In 1979, Richard Bandler and John Grinder established the Society of Neuro-Linguistic Programming (NLP) to manage commercial applications of NLP, including training, materials, and certification. The founding agreement conferred exclusive rights to profit from NLP training and certification upon Bandler's corporate entity, Not Ltd. Around November 1980, Bandler and Grinder had ceased collaboration for undisclosed reasons.
On September 25, 1981, Bandler filed suit against Grinder's corporate entity, Unlimited Ltd., in the Superior Court of California, County of Santa Cruz seeking injunctive relief and damages arising from Grinder's NLP-related commercial activities; the Court issued a judgment in Bandler's favor on October 29, 1981. The subsequent settlement agreement granted Grinder a 10-year license to conduct NLP seminars, offer NLP certification, and utilize the NLP name, subject to royalty payments to Bandler.
=== Further litigation and consequences (1996–
|
https://en.wikipedia.org/wiki/Neuro-linguistic_programming
|
.
=== Further litigation and consequences (1996–2000) ===
Bandler commenced further civil actions against Unlimited Ltd., various figures within the NLP community, and 200 initially unnamed defendants in July 1996 and January 1997. Bandler alleged violations of the initial settlement terms by Grinder and sought damages of no less than US$10,000,000.00 from each defendant.
In February 2000, the Court ruled against Bandler. The judgment asserted that Bandler had misrepresented his exclusive ownership of NLP intellectual property and sole authority over Society of NLP membership and certification.
=== Trademark revocation (1997) ===
In December 1997, a separate civil proceeding initiated by Tony Clarkson resulted in the revocation of Bandler's UK trademark of NLP. The Court ruled in Clarkson's favor.
=== Resolution and legacy (2000) ===
Bandler and Grinder reached a settlement in late 2000, acknowledging their status as co-creators and co-founders of NLP and committing to refrain fr
|
https://en.wikipedia.org/wiki/Neuro-linguistic_programming
|
nd co-founders of NLP and committing to refrain from disparaging one another's NLP-related endeavors.
Due to these disputes and settlements, the terms "NLP" and "neuro-linguistic programming" remain in the public domain. No single party holds exclusive rights, and there are no restrictions on offering NLP certifications.
The designations "NLP" and "neuro-linguistic programming" are not owned, trademarked, or subject to centralized regulation. Consequently, there are no restrictions on individuals self-identifying as "NLP master practitioners" or "NLP master trainers". This decentralization has led to numerous certifying associations.
=== Decentralization and criticism ===
This lack of centralized control means there is no single standard for NLP practice or training. Practitioners can market their own methodologies, leading to inconsistencies within the field. This has been a source of criticism, highlighted by an incident in 2009 where a British television presenter registered his
|
https://en.wikipedia.org/wiki/Neuro-linguistic_programming
|
ere a British television presenter registered his cat with the British Board of Neuro Linguistic Programming (BBNLP), demonstrating the organization's lax credentialing. Critics like Karen Stollznow find irony in the initial legal battles between Bandler and Grinder, considering their failure to apply their own NLP principles to resolve their conflict. Others, such as Grant Devilly, characterize NLP associations as "granfalloons"—a term implying a lack of unifying principles or a shared sense of purpose.
== See also ==
Avatar Course
Family systems therapy
Frank Farrelly
List of New Age topics
List of unproven and disproven cancer treatments
Solution-focused brief therapy
Notable practitioners
Steve Andreas
Paul McKenna
== Notes ==
== References ==
=== Citations ===
=== Works cited ===
Primary sources
Secondary sources
== Further reading ==
== External links ==
The dictionary definition of Neuro-linguistic programming at Wiktionary
Media related to Neuro-linguistic pro
|
https://en.wikipedia.org/wiki/Neuro-linguistic_programming
|
Wiktionary
Media related to Neuro-linguistic programming at Wikimedia Commons
Quotations related to Neuro-linguistic programming at Wikiquote
|
https://en.wikipedia.org/wiki/Neuro-linguistic_programming
|
Literate programming is a programming paradigm introduced in 1984 by Donald Knuth in which a computer program is given as an explanation of how it works in a natural language, such as English, interspersed (embedded) with snippets of macros and traditional source code, from which compilable source code can be generated. The approach is used in scientific computing and in data science routinely for reproducible research and open access purposes. Literate programming tools are used by millions of programmers today.
The literate programming paradigm, as conceived by Donald Knuth, represents a move away from writing computer programs in the manner and order imposed by the compiler, and instead gives programmers macros to develop programs in the order demanded by the logic and flow of their thoughts. Literate programs are written as an exposition of logic in more natural language in which macros are used to hide abstractions and traditional source code, more like the text of an essay.
Lite
|
https://en.wikipedia.org/wiki/Literate_programming
|
source code, more like the text of an essay.
Literate programming (LP) tools are used to obtain two representations from a source file: one understandable by a compiler or interpreter, the "tangled" code, and another for viewing as formatted documentation, which is said to be "woven" from the literate source. While the first generation of literate programming tools were computer language-specific, the later ones are language-agnostic and exist beyond the individual programming languages.
== History and philosophy ==
Literate programming was first introduced in 1984 by Donald Knuth, who intended it to create programs that were suitable literature for human beings. He implemented it at Stanford University as a part of his research on algorithms and digital typography. The implementation was called "WEB" since he believed that it was one of the few three-letter words of English that had not yet been applied to computing. However, it resembles the complicated nature of software delicate
|
https://en.wikipedia.org/wiki/Literate_programming
|
embles the complicated nature of software delicately pieced together from simple materials. The practice of literate programming has seen an important resurgence in the 2010s with the use of computational notebooks, especially in data science.
== Concept ==
Literate programming is writing out the program logic in a human language with included (separated by a primitive markup) code snippets and macros. Macros in a literate source file are simply title-like or explanatory phrases in a human language that describe human abstractions created while solving the programming problem, and hiding chunks of code or lower-level macros. These macros are similar to the algorithms in pseudocode typically used in teaching computer science. These arbitrary explanatory phrases become precise new operators, created on the fly by the programmer, forming a meta-language on top of the underlying programming language.
A preprocessor is used to substitute arbitrary hierarchies, or rather "interconnected 'w
|
https://en.wikipedia.org/wiki/Literate_programming
|
rbitrary hierarchies, or rather "interconnected 'webs' of macros", to produce the compilable source code with one command ("tangle"), and documentation with another ("weave"). The preprocessor also provides an ability to write out the content of the macros and to add to already created macros in any place in the text of the literate program source file, thereby disposing of the need to keep in mind the restrictions imposed by traditional programming languages or to interrupt the flow of thought.
=== Advantages ===
According to Knuth,
literate programming provides higher-quality programs, since it forces programmers to explicitly state the thoughts behind the program, making poorly thought-out design decisions more obvious. Knuth also claims that literate programming provides a first-rate documentation system, which is not an add-on, but is grown naturally in the process of exposition of one's thoughts during a program's creation. The resulting documentation allows the author to resta
|
https://en.wikipedia.org/wiki/Literate_programming
|
resulting documentation allows the author to restart their own thought processes at any later time, and allows other programmers to understand the construction of the program more easily. This differs from traditional documentation, in which a programmer is presented with source code that follows a compiler-imposed order, and must decipher the thought process behind the program from the code and its associated comments. The meta-language capabilities of literate programming are also claimed to facilitate thinking, giving a higher "bird's eye view" of the code and increasing the number of concepts the mind can successfully retain and process. Applicability of the concept to programming on a large scale, that of commercial-grade programs, is proven by an edition of TeX code as a literate program.
Knuth also claims that literate programming can lead to easy porting of software to multiple environments, and even cites the implementation of TeX as an example.
=== Contrast with documentati
|
https://en.wikipedia.org/wiki/Literate_programming
|
TeX as an example.
=== Contrast with documentation generation ===
Literate programming is very often misunderstood to refer only to formatted documentation produced from a common file with both source code and comments – which is properly called documentation generation – or to voluminous commentaries included with code. This is the converse of literate programming: well-documented code or documentation extracted from code follows the structure of the code, with documentation embedded in the code; while in literate programming, code is embedded in documentation, with the code following the structure of the documentation.
This misconception has led to claims that comment-extraction tools, such as the Perl Plain Old Documentation or Java Javadoc systems, are "literate programming tools". However, because these tools do not implement the "web of abstract concepts" hiding behind the system of natural-language macros, or provide an ability to change the order of the source code from a ma
|
https://en.wikipedia.org/wiki/Literate_programming
|
y to change the order of the source code from a machine-imposed sequence to one convenient to the human mind, they cannot properly be called literate programming tools in the sense intended by Knuth.
== Workflow ==
Implementing literate programming consists of two steps:
Weaving: Generating a comprehensive document about the program and its maintenance.
Tangling: Generating machine executable code
Weaving and tangling are done on the same source so that they are consistent with each other.
== Example ==
A classic example of literate programming is the literate implementation of the standard Unix wc word counting program. Knuth presented a CWEB version of this example in Chapter 12 of his Literate Programming book. The same example was later rewritten for the noweb literate programming tool. This example provides a good illustration of the basic elements of literate programming.
=== Creation of macros ===
The following snippet of the wc literate program shows how arbitrary descri
|
https://en.wikipedia.org/wiki/Literate_programming
|
the wc literate program shows how arbitrary descriptive phrases in a natural language are used in a literate program to create macros, which act as new "operators" in the literate programming language, and hide chunks of code or other macros. The mark-up notation consists of double angle brackets (<<...>>) that indicate macros. The @ symbol, in a noweb file, indicates the beginning of a documentation chunk. The <<*>> symbol stands for the "root", topmost node the literate programming tool will start expanding the web of macros from. Actually, writing out the expanded source code can be done from any section or subsection (i.e. a piece of code designated as <<name of the chunk>>=, with the equal sign), so one literate program file can contain several files with machine source code.
The unraveling of the chunks can be done in any place in the literate program text file, not necessarily in the order they are sequenced in the enclosing chunk, but as is demanded by the logic reflected in t
|
https://en.wikipedia.org/wiki/Literate_programming
|
nk, but as is demanded by the logic reflected in the explanatory text that envelops the whole program.
=== Program as a web ===
Macros are not the same as "section names" in standard documentation. Literate programming macros hide the real code behind themselves, and be used inside any low-level machine language operators, often inside logical operators such as if, while or case. This can be seen in the following wc literate program.
The macros stand for any chunk of code or other macros, and are more general than top-down or bottom-up "chunking", or than subsectioning. Donald Knuth said that when he realized this, he began to think of a program as a web of various parts.
=== Order of human logic, not that of the compiler ===
In a noweb literate program besides the free order of their exposition, the chunks behind macros, once introduced with <<...>>=, can be grown later in any place in the file by simply writing <<name of the chunk>>= and adding more content to it, as the followi
|
https://en.wikipedia.org/wiki/Literate_programming
|
k>>= and adding more content to it, as the following snippet illustrates (+ is added by the document formatter for readability, and is not in the code).
The grand totals must be initialized to zero at the beginning of the program.
If we made these variables local to main, we would have to do this initialization
explicitly; however, C globals are automatically zeroed. (Or rather,``statically
zeroed.'' (Get it?)
<<Global variables>>+=
long tot_word_count, tot_line_count,
tot_char_count;
/* total number of words, lines, chars */
@
=== Record of the train of thought ===
The documentation for a literate program is produced as part of writing the program. Instead of comments provided as side notes to source code a literate program contains the explanation of concepts on each level, with lower level concepts deferred to their appropriate place, which allows for better communication of thought. The snippets of the literate wc above show how an explanation of t
|
https://en.wikipedia.org/wiki/Literate_programming
|
the literate wc above show how an explanation of the program and its source code are interwoven. Such exposition of ideas creates the flow of thought that is like a literary work. Knuth wrote a "novel" which explains the code of the interactive fiction game Colossal Cave Adventure.
=== Remarkable examples ===
Axiom, which is evolved from Scratchpad, a computer algebra system developed by IBM. It is now being developed by Tim Daly, one of the developers of Scratchpad, Axiom is totally written as a literate program.
== Literate programming practices ==
The first published literate programming environment was WEB, introduced by Knuth in 1981 for his TeX typesetting system; it uses Pascal as its underlying programming language and TeX for typesetting of the documentation. The complete commented TeX source code was published in Knuth's TeX: The program, volume B of his 5-volume Computers and Typesetting. Knuth had privately used a literate programming system called DOC as early as 1979.
|
https://en.wikipedia.org/wiki/Literate_programming
|
te programming system called DOC as early as 1979. He was inspired by the ideas of Pierre-Arnoul de Marneffe. The free CWEB, written by Knuth and Silvio Levy, is WEB adapted for C and C++, runs on most operating systems, and can produce TeX and PDF documentation.
There are various other implementations of the literate programming concept as given below. Many of the newer among these do not have macros and hence do not comply with the order of human logic principle, which makes them perhaps "semi-literate" tools. These, however, allow cellular execution of code which makes them more along the lines of exploratory programming tools.
Other useful tools include:
== See also ==
Documentation generator – the inverse on literate programming where documentation is embedded in and generated from source code
Notebook interface – virtual notebook environment used for literate programming
Sweave and Knitr – examples of use of the "noweb"-like Literate Programming tool inside the R language for
|
https://en.wikipedia.org/wiki/Literate_programming
|
iterate Programming tool inside the R language for creation of dynamic statistical reports
Self-documenting code – source code that can be easily understood without documentation
== References ==
== Further reading ==
== External links ==
LiterateProgramming at WikiWikiWeb
Literate Programming FAQ at CTAN
|
https://en.wikipedia.org/wiki/Literate_programming
|
In computer programming, dataflow programming is a programming paradigm that models a program as a directed graph of the data flowing between operations, thus implementing dataflow principles and architecture. Dataflow programming languages share some features of functional languages, and were generally developed in order to bring some functional concepts to a language more suitable for numeric processing. Some authors use the term datastream instead of dataflow to avoid confusion with dataflow computing or dataflow architecture, based on an indeterministic machine paradigm. Dataflow programming was pioneered by Jack Dennis and his graduate students at MIT in the 1960s.
== Considerations ==
Traditionally, a program is modelled as a series of operations happening in a specific order; this may be referred to as sequential,: p.3
procedural,
control flow (indicating that the program chooses a specific path), or imperative programming. The program focuses on commands, in line with the vo
|
https://en.wikipedia.org/wiki/Dataflow_programming
|
e program focuses on commands, in line with the von Neumann: p.3 vision of sequential programming, where data is normally "at rest".: p.7
In contrast, dataflow programming emphasizes the movement of data and models programs as a series of connections. Explicitly defined inputs and outputs connect operations, which function like black boxes.: p.2 An operation runs as soon as all of its inputs become valid. Thus, dataflow languages are inherently parallel and can work well in large, decentralized systems.: p.3
=== State ===
One of the key concepts in computer programming is the idea of state, essentially a snapshot of various conditions in the system. Most programming languages require a considerable amount of state information, which is generally hidden from the programmer. Often, the computer itself has no idea which piece of information encodes the enduring state. This is a serious problem, as the state information needs to be shared across multiple processors in parallel proces
|
https://en.wikipedia.org/wiki/Dataflow_programming
|
ared across multiple processors in parallel processing machines. Most languages force the programmer to add extra code to indicate which data and parts of the code are important to the state. This code tends to be both expensive in terms of performance, as well as difficult to read or debug. Explicit parallelism is one of the main reasons for the poor performance of Enterprise Java Beans when building data-intensive, non-OLTP applications.
Where a sequential program can be imagined as a single worker moving between tasks (operations), a dataflow program is more like a series of workers on an assembly line, each doing a specific task whenever materials are available. Since the operations are only concerned with the availability of data inputs, they have no hidden state to track, and are all "ready" at the same time.
=== Representation ===
Dataflow programs are represented in different ways. A traditional program is usually represented as a series of text instructions, which is reasona
|
https://en.wikipedia.org/wiki/Dataflow_programming
|
as a series of text instructions, which is reasonable for describing a serial system which pipes data between small, single-purpose tools that receive, process, and return. Dataflow programs start with an input, perhaps the command line parameters, and illustrate how that data is used and modified. The flow of data is explicit, often visually illustrated as a line or pipe.
In terms of encoding, a dataflow program might be implemented as a hash table, with uniquely identified inputs as the keys, used to look up pointers to the instructions. When any operation completes, the program scans down the list of operations until it finds the first operation where all inputs are currently valid, and runs it. When that operation finishes, it will typically output data, thereby making another operation become valid.
For parallel operation, only the list needs to be shared; it is the state of the entire program. Thus the task of maintaining state is removed from the programmer and given to the lang
|
https://en.wikipedia.org/wiki/Dataflow_programming
|
removed from the programmer and given to the language's runtime. On machines with a single processor core where an implementation designed for parallel operation would simply introduce overhead, this overhead can be removed completely by using a different runtime.
=== Incremental updates ===
Some recent dataflow libraries such as Differential/Timely Dataflow have used incremental computing for much more efficient data processing.
== History ==
A pioneer dataflow language was BLOck DIagram (BLODI), published in 1961 by John Larry Kelly, Jr., Carol Lochbaum and Victor A. Vyssotsky for specifying sampled data systems. A BLODI specification of functional units (amplifiers, adders, delay lines, etc.) and their interconnections was compiled into a single loop that updated the entire system for one clock tick.
In a 1966 Ph.D. thesis, The On-line Graphical Specification of Computer Procedures, Bert Sutherland created one of the first graphical dataflow programming frameworks in order to m
|
https://en.wikipedia.org/wiki/Dataflow_programming
|
ical dataflow programming frameworks in order to make parallel programming easier. Subsequent dataflow languages were often developed at the large supercomputer labs. POGOL, an otherwise conventional data-processing language developed at NSA, compiled large-scale applications composed of multiple file-to-file operations, e.g. merge, select, summarize, or transform, into efficient code that eliminated the creation of or writing to intermediate files to the greatest extent possible. SISAL, a popular dataflow language developed at Lawrence Livermore National Laboratory, looks like most statement-driven languages, but variables should be assigned once. This allows the compiler to easily identify the inputs and outputs. A number of offshoots of SISAL have been developed, including SAC, Single Assignment C, which tries to remain as close to the popular C programming language as possible.
The United States Navy funded development of signal processing graph notation (SPGN) and ACOS starting in
|
https://en.wikipedia.org/wiki/Dataflow_programming
|
cessing graph notation (SPGN) and ACOS starting in the early 1980s. This is in use on a number of platforms in the field today.
A more radical concept is Prograph, in which programs are constructed as graphs onscreen, and variables are replaced entirely with lines linking inputs to outputs. Prograph was originally written on the Macintosh, which remained single-processor until the introduction of the DayStar Genesis MP in 1996.
There are many hardware architectures oriented toward the efficient implementation of dataflow programming models. MIT's tagged token dataflow architecture was designed by Greg Papadopoulos.
Data flow has been proposed as an abstraction for specifying the global behavior of distributed system components: in the live distributed objects programming model, distributed data flows are used to store and communicate state, and as such, they play the role analogous to variables, fields, and parameters in Java-like programming languages.
== Languages ==
Dataflow prog
|
https://en.wikipedia.org/wiki/Dataflow_programming
|
amming languages.
== Languages ==
Dataflow programming languages include:
Céu (programming language)
ASCET
AviSynth scripting language, for video processing
BMDFM Binary Modular Dataflow Machine
CAL
Cuneiform, a functional workflow language.
CMS Pipelines
Hume
Joule
Keysight VEE
KNIME is a free and open-source data analytics, reporting and integration platform
LabVIEW, G
Linda
Lucid
Lustre
Max/MSP
Microsoft Visual Programming Language - A component of Microsoft Robotics Studio designed for robotics programming
Nextflow: a workflow language
Orange - An open-source, visual programming tool for data mining, statistical data analysis, and machine learning.
Oz now also distributed since 1.4.0
Pipeline Pilot
Prograph
Pure Data
Quartz Composer - Designed by Apple; used for graphic animations and effects
SAC Single assignment C
SIGNAL (a dataflow-oriented synchronous language enabling multi-clock specifications)
Simulink
SISAL
SystemVerilog - A hardware description language
Verilog - A har
|
https://en.wikipedia.org/wiki/Dataflow_programming
|
- A hardware description language
Verilog - A hardware description language absorbed into the SystemVerilog standard in 2009
VisSim - A block diagram language for simulation of dynamic systems and automatic firmware generation
VHDL - A hardware description language
Wapice IOT-TICKET implements an unnamed visual dataflow programming language for IoT data analysis and reporting.
XEE (Starlight) XML engineering environment
XProc
== Libraries ==
Apache Beam: Java/Scala SDK that unifies streaming (and batch) processing with several execution engines supported (Apache Spark, Apache Flink, Google Dataflow etc.)
Apache Flink: Java/Scala library that allows streaming (and batch) computations to be run atop a distributed Hadoop (or other) cluster
Apache Spark
SystemC: Library for C++, mainly aimed at hardware design.
TensorFlow: A machine-learning library based on dataflow programming.
== See also ==
Actor model
Data-driven programming
Digital signal processing
Event-driven programming
Flow
|
https://en.wikipedia.org/wiki/Dataflow_programming
|
al signal processing
Event-driven programming
Flow-based programming
Functional reactive programming
Glossary of reconfigurable computing
High-performance reconfigurable computing
Incremental computing
Parallel programming model
Partitioned global address space
Pipeline (Unix)
Quantum circuit
Signal programming
Stream processing
Yahoo Pipes
== References ==
== External links ==
Book: Dataflow and Reactive Programming Systems
Basics of Dataflow Programming in F# and C#
Dataflow Programming - Concept, Languages and Applications
Static Scheduling of Synchronous Data Flow Programs for Digital Signal Processing
Handling huge loads without adding complexity The basic concepts of dataflow programming, Dr. Dobb's, Sept. 2011
|
https://en.wikipedia.org/wiki/Dataflow_programming
|
Differentiable programming is a programming paradigm in which a numeric computer program can be differentiated throughout via automatic differentiation. This allows for gradient-based optimization of parameters in the program, often via gradient descent, as well as other learning approaches that are based on higher-order derivative information. Differentiable programming has found use in a wide variety of areas, particularly scientific computing and machine learning. One of the early proposals to adopt such a framework in a systematic fashion to improve upon learning algorithms was made by the Advanced Concepts Team at the European Space Agency in early 2016.
== Approaches ==
Most differentiable programming frameworks work by constructing a graph containing the control flow and data structures in the program. Attempts generally fall into two groups:
Static, compiled graph-based approaches such as TensorFlow, Theano, and MXNet. They tend to allow for good compiler optimization and e
|
https://en.wikipedia.org/wiki/Differentiable_programming
|
tend to allow for good compiler optimization and easier scaling to large systems, but their static nature limits interactivity and the types of programs that can be created easily (e.g. those involving loops or recursion), as well as making it harder for users to reason effectively about their programs. A proof-of-concept compiler toolchain called Myia uses a subset of Python as a front end and supports higher-order functions, recursion, and higher-order derivatives.
Operator overloading, dynamic graph-based approaches such as PyTorch, NumPy's autograd package, and Pyaudi. Their dynamic and interactive nature lets most programs be written and reasoned about more easily. However, they lead to interpreter overhead (particularly when composing many small operations), poorer scalability, and reduced benefit from compiler optimization.
The use of just-in-time compilation has emerged recently as a possible solution to overcome some of the bottlenecks of interpreted languages. The C++ heyoka
|
https://en.wikipedia.org/wiki/Differentiable_programming
|
tlenecks of interpreted languages. The C++ heyoka and Python package heyoka.py make large use of this technique to offer advanced differentiable programming capabilities (also at high orders). A package for the Julia programming language – Zygote – works directly on Julia's intermediate representation.
A limitation of earlier approaches is that they are only able to differentiate code written in a suitable manner for the framework, limiting their interoperability with other programs. Newer approaches resolve this issue by constructing the graph from the language's syntax or IR, allowing arbitrary code to be differentiated.
== Applications ==
Differentiable programming has been applied in areas such as combining deep learning with physics engines in robotics, solving electronic-structure problems with differentiable density functional theory, differentiable ray tracing, differentiable imaging, image processing, and probabilistic programming.
== Multidisciplinary application ==
Dif
|
https://en.wikipedia.org/wiki/Differentiable_programming
|
ramming.
== Multidisciplinary application ==
Differentiable programming is making significant strides in various fields beyond its traditional applications. In healthcare and life sciences, for example, it is being used for deep learning in biophysics-based modelling of molecular mechanisms, in areas such as protein structure prediction and drug discovery. These applications demonstrate the potential of differentiable programming in contributing to significant advancements in understanding complex biological systems and improving healthcare solutions.
== See also ==
Differentiable function
Machine learning
== Notes ==
== References ==
|
https://en.wikipedia.org/wiki/Differentiable_programming
|
Brokered programming (also known as time-buy and blocktime) is a form of broadcast content in which the show's producer pays a radio or television station for air time, rather than exchanging programming for pay or the opportunity to play spot commercials. A brokered program is typically not capable of garnering enough support from advertisements to pay for itself, and may be controversial, esoteric or an advertisement in itself.
== Overview ==
=== Common examples ===
Common examples are religious and political programs and talk-show-format programs similar to infomercial on television. Others are hobby programs or vanity programs paid for by the host and/or their supporters, and may be intended to promote the host's personality, for instance in preparation for a political campaign, or to promote a product, service or business that the host is closely associated with. A live vanity show may be carried on several stations by remote broadcast or simulcast, with the producer paying mu
|
https://en.wikipedia.org/wiki/Brokered_programming
|
roadcast or simulcast, with the producer paying multiple stations an airtime fee. Financial advisors and planners often produce this kind of programming.
Brokered commercial programs promote products or services by scripting shows made to sound similar to talk radio or news programming, and may even include calls from actual listeners (or actors playing the part of listeners). The programs are a specific type of infomercial, as they focus on a topic related to the product and repeatedly steer listeners and "callers" to a particular website and/or toll-free telephone number in order to purchase the product being featured. Although presented in the style of live programs, these are typically pre-recorded and supplied to stations on tape, disc, or digital downloadable formats, such as MP3 files.
Such programming is most common on talk radio stations and used to fill non-prime time slots and to augment income from spot-advertisement sales during normal programs.
Most of these programs feat
|
https://en.wikipedia.org/wiki/Brokered_programming
|
uring normal programs.
Most of these programs feature a disclaimer at either the beginning or the end of the program (or both), usually read by the program's host or (most often) by a separate announcer; some radio stations play a standard disclaimer before all such programs.
Certain mainstream sports and entertainment broadcasts may resort to buying brokered airtime to air on television if they cannot secure a deal that pays rights fees or a barter agreement. Examples include the last years of the Professional Bowlers Tour, Major League Baseball's short-lived The Baseball Network venture in the mid-1990s, professional football leagues such as the United Football League and Alliance of American Football, and motorsports events produced and sponsored by Lucas Oil. In the case of professional football, brokered programming has typically not been feasible in the long term, as the sport requires rights fees to make it viable; leagues that have relied on brokering television time have colla
|
https://en.wikipedia.org/wiki/Brokered_programming
|
ave relied on brokering television time have collapsed in short order due to financial losses. Regional sports networks also pad their non-play-by-play schedule with brokered shows catering to niches like high school sports, poker, and all-terrain vehicles. Some packages of high school football and basketball games are brokered more with the specific purposes of college recruiting and future name, image, and likeness deals in mind rather than the actual team matchup, which is mainly prevalent with nationally-ranked high school athletic powers that do not play traditional local schedules against local opponents and highlight certain heavily-recruited players.
=== Radio ===
==== Talk radio ====
Although some syndicators of multi-topic, ad-supported talk shows may pay a fee to stations with very large Arbitron-verified listenership, the same syndicator will normally charge a fee to small stations and may charge nothing to stations with moderate listenership. Each arrangement depends o
|
https://en.wikipedia.org/wiki/Brokered_programming
|
moderate listenership. Each arrangement depends on whether the station can deliver enough listeners to allow the syndicator to earn money from ad sales. Syndicated programs normally carry a number of their own advertisements that must be played during commercial breaks, but set aside time for local stations to play their own advertisements.
Stations also frequently employ one or more of their own hosts, but at some small stations these hosts may be unpaid volunteers motivated by the chance to promote an agenda, gain personal exposure or get work experience.
The use of brokered programming varies by station -- some stations, mainly news radio and sports radio stations, use brokered programming to fill holes in some dayparts, especially during the late-night hours and weekends. The format of brokered programs varies; many sports radio stations will use brokered programs from sports handicappers and prognosticators to fit their format, while news and talk radio stations will often rely o
|
https://en.wikipedia.org/wiki/Brokered_programming
|
ile news and talk radio stations will often rely on brokered programs that sell vitamin or nutritional supplements, financial planning products and services, and alternative medical products, fitting those stations' older audiences.
Sometimes, even programs dealing with gardening and home improvement (usually presented on weekend mornings on many talk radio stations) are broadcast under a brokered arrangement, as was the case with KRLD gardening expert Neil Sperry before his show was canceled outright in 2010.
Program time is often brokered to churches on Sunday mornings in a manner that parallels televangelism; there are also religious stations that rely primarily on brokered programs, and these stations often get the derisive title of "pay for pray," a play on the unethical practice of "pay for play" on music stations. There are also some AM radio stations that are dedicated to the brokered format, selling time for as little as 15 minutes or even selling the entire broadcasting day
|
https://en.wikipedia.org/wiki/Brokered_programming
|
nutes or even selling the entire broadcasting day to a single entity, with the station holding the broadcast license and providing the facilities. That long-form type of brokered programming is especially popular among ethnic and religious broadcasters as well as with privately owned U.S.-based shortwave radio broadcasters.
==== Music radio programs ====
Brokered programs are not exclusive to talk radio; music radio programs can also be brokered. The brokered format, popular among specialty and niche music formats (e.g. polka music), usually involves the show itself lining up its own advertising and paying the station for its airtime. The idea reduces the risk for the station and assures the show remains on the air as long as the show's producers continue to pay the station's airtime fee.
=== Record companies ===
Record companies (through independent promoters) may also purchase brokered time on music stations to have the station play a new single as a "preview", which has the pot
|
https://en.wikipedia.org/wiki/Brokered_programming
|
lay a new single as a "preview", which has the potential to be inserted onto a station's general playlist but has not received the traction to do so. These spots are often the length of the song with an introduction and disclaimer at the end of the song stating the artist, album title, and releasing label, and come under titles such as CD Preview. The segments must be carefully disclaimed by the record companies so as to not violate payola laws and the playing of the song, as it is paid for, cannot be applied to song popularity charts, as has happened in the early 2000s with some forms of this concept.
=== Brokered time through agencies ===
Oftentimes broadcasters will seek the help of an ad agency to secure a brokered radio show. Agencies such as I Buy Time in Dallas, Texas or Bayliss Media Group in Los Angeles, California have the knowledge on how to negotiate a lower per-hour rate than what may be quoted by the radio station to the individual broadcaster.
=== Local marketing agr
|
https://en.wikipedia.org/wiki/Brokered_programming
|
individual broadcaster.
=== Local marketing agreements ===
If a station sells all of its time to a programmer, essentially leasing the station, it is a local marketing agreement (LMA). Like owning a station, this counts toward United States Federal Communications Commission (FCC) and Canadian Radio-television and Telecommunications Commission (CRTC) caps that prevent excessive concentration of media ownership in the U.S. and Canada. However, in the case of television stations, LMA's do not count towards caps in the U.S.
== Examples of brokered, non-religious programming ==
Financial planning/advice/services
Investors Edge with Gary Kaltbaum
The Mutual Fund Show
The Ray Lucia Show
Other
ASAP (via A2Z and TV5)
Eat Bulaga! (via TV5 and RPTV/RPN)
Goin' Bulilit (via A2Z and All TV)
It's Showtime (via A2Z, All TV and GMA Network)
The Kevin Trudeau Show
Maalaala Mo Kaya (via A2Z and All TV)
Music
Ernest Tubb's Midnite Jamboree
Sports
Calling All Sports With Roc and Manuch
News and Tal
|
https://en.wikipedia.org/wiki/Brokered_programming
|
alling All Sports With Roc and Manuch
News and Talk
Magandang Buhay (via A2Z and All TV)
NewsWatch Plus (via RPTV/RPN and Aliw Channel 23)
Radio Sputnik (via RM Broadcasting)
TV Patrol (via A2Z, All TV, DWPM Radyo 630 and PRTV Prime Media)
== See also ==
Talk radio
Infomercial
Leased access (for cable television)
Advertising
== Footnotes ==
|
https://en.wikipedia.org/wiki/Brokered_programming
|
"Epigrams on Programming" is an article by Alan Perlis published in 1982, for ACM's SIGPLAN journal. The epigrams are a series of short, programming-language-neutral, humorous statements about computers and programming, which are widely quoted.
It first appeared in SIGPLAN Notices 17(9), September 1982.
In epigram #54, Perlis coined the term "Turing tarpit", which he defined as a programming language where "everything is possible but nothing of interest is easy."
== References ==
Perlis, A. J. (September 1982). "Epigrams on programming". ACM SIGPLAN Notices. 17 (9). New York, NY, USA: Association for Computing Machinery: 7–13. doi:10.1145/947955.1083808. Archived from the original on January 17, 1999.
== External links ==
List of quotes (Yale)
Full article text -- (including so-called "meta epigrams", numbers 122-130)
|
https://en.wikipedia.org/wiki/Epigrams_on_Programming
|
A programming paradigm is a relatively high-level way to conceptualize and structure the implementation of a computer program. A programming language can be classified as supporting one or more paradigms.
Paradigms are separated along and described by different dimensions of programming. Some paradigms are about implications of the execution model, such as allowing side effects, or whether the sequence of operations is defined by the execution model. Other paradigms are about the way code is organized, such as grouping into units that include both state and behavior. Yet others are about syntax and grammar.
Some common programming paradigms include (shown in hierarchical relationship):
Imperative – code directly controls execution flow and state change, explicit statements that change a program state
procedural – organized as procedures that call each other
object-oriented – organized as objects that contain both data structure and associated behavior, uses data structures consisting
|
https://en.wikipedia.org/wiki/Programming_paradigm
|
ociated behavior, uses data structures consisting of data fields and methods together with their interactions (objects) to design programs
Class-based – object-oriented programming in which inheritance is achieved by defining classes of objects, versus the objects themselves
Prototype-based – object-oriented programming that avoids classes and implements inheritance via cloning of instances
Declarative – code declares properties of the desired result, but not how to compute it, describes what computation should perform, without specifying detailed state changes
functional – a desired result is declared as the value of a series of function evaluations, uses evaluation of mathematical functions and avoids state and mutable data
logic – a desired result is declared as the answer to a question about a system of facts and rules, uses explicit mathematical logic for programming
reactive – a desired result is declared with data streams and the propagation of change
Concurrent programming – ha
|
https://en.wikipedia.org/wiki/Programming_paradigm
|
propagation of change
Concurrent programming – has language constructs for concurrency, these may involve multi-threading, support for distributed computing, message passing, shared resources (including shared memory), or futures
Actor programming – concurrent computation with actors that make local decisions in response to the environment (capable of selfish or competitive behaviour)
Constraint programming – relations between variables are expressed as constraints (or constraint networks), directing allowable solutions (uses constraint satisfaction or simplex algorithm)
Dataflow programming – forced recalculation of formulas when data values change (e.g. spreadsheets)
Distributed programming – has support for multiple autonomous computers that communicate via computer networks
Generic programming – uses algorithms written in terms of to-be-specified-later types that are then instantiated as needed for specific types provided as parameters
Metaprogramming – writing programs that write
|
https://en.wikipedia.org/wiki/Programming_paradigm
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.