text
stringlengths 128
4k
| source
stringlengths 31
152
|
|---|---|
Computer programming or coding is the composition of sequences of instructions, called programs, that computers can follow to perform tasks. It involves designing and implementing algorithms, step-by-step specifications of procedures, by writing code in one or more programming languages. Programmers typically use high-level programming languages that are more easily intelligible to humans than machine code, which is directly executed by the central processing unit. Proficient programming usually requires expertise in several different subjects, including knowledge of the application domain, details of programming languages and generic code libraries, specialized algorithms, and formal logic.
Auxiliary tasks accompanying and related to programming include analyzing requirements, testing, debugging (investigating and fixing problems), implementation of build systems, and management of derived artifacts, such as programs' machine code. While these are sometimes considered programming, often the term software development is used for this larger overall process – with the terms programming, implementation, and coding reserved for the writing and editing of code per se. Sometimes software development is known as software engineering, especially when it employs formal methods or follows an engineering design process.
== History ==
Programmable devices have existed for centuries. As early as the 9th century, a programmable music sequencer was invented by the Persian Banu Musa brothers, who described an automated mechanical flute player in the Book of Ingenious Devices. In 1206, the Arab engineer Al-Jazari invented a programmable drum machine where a musical mechanical automaton could be made to play different rhythms and drum patterns, via pegs and cams. In 1801, the Jacquard loom could produce entirely different weaves by changing the "program" – a series of pasteboard cards with holes punched in them.
Code-breaking algorithms have also existed for centuries. In the 9th century, the Arab mathematician Al-Kindi described a cryptographic algorithm for deciphering encrypted code, in A Manuscript on Deciphering Cryptographic Messages. He gave the first description of cryptanalysis by frequency analysis, the earliest code-breaking algorithm.
The first computer program is generally dated to 1843 when mathematician Ada Lovelace published an algorithm to calculate a sequence of Bernoulli numbers, intended to be carried out by Charles Babbage's Analytical Engine. The algorithm, which was conveyed through notes on a translation of Luigi Federico Menabrea's paper on the analytical engine was mainly conceived by Lovelace as can be discerned through her correspondence with Babbage. However, Charles Babbage himself had written a program for the AE in 1837. Lovelace was also the first to see a broader application for the analytical engine beyond mathematical calculations.
In the 1880s, Herman Hollerith invented the concept of storing data in machine-readable form. Later a control panel (plug board) added to his 1906 Type I Tabulator allowed it to be programmed for different jobs, and by the late 1940s, unit record equipment such as the IBM 602 and IBM 604, were programmed by control panels in a similar way, as were the first electronic computers. However, with the concept of the stored-program computer introduced in 1949, both programs and data were stored and manipulated in the same way in computer memory.
=== Machine language ===
Machine code was the language of early programs, written in the instruction set of the particular machine, often in binary notation. Assembly languages were soon developed that let the programmer specify instructions in a text format (e.g., ADD X, TOTAL), with abbreviations for each operation code and meaningful names for specifying addresses. However, because an assembly language is little more than a different notation for a machine language, two machines with different instruction sets also have different asse
|
https://en.wikipedia.org/wiki/Computer_programming
|
A programming language is a system of notation for writing computer programs.
Programming languages are described in terms of their syntax (form) and semantics (meaning), usually defined by a formal language. Languages usually provide features such as a type system, variables, and mechanisms for error handling. An implementation of a programming language is required in order to execute programs, namely an interpreter or a compiler. An interpreter directly executes the source code, while a compiler produces an executable program.
Computer architecture has strongly influenced the design of programming languages, with the most common type (imperative languages—which implement operations in a specified order) developed to perform well on the popular von Neumann architecture. While early programming languages were closely tied to the hardware, over time they have developed more abstraction to hide implementation details for greater simplicity.
Thousands of programming languages—often classified as imperative, functional, logic, or object-oriented—have been developed for a wide variety of uses. Many aspects of programming language design involve tradeoffs—for example, exception handling simplifies error handling, but at a performance cost. Programming language theory is the subfield of computer science that studies the design, implementation, analysis, characterization, and classification of programming languages.
== Definitions ==
Programming languages differ from natural languages in that natural languages are used for interaction between people, while programming languages are designed to allow humans to communicate instructions to machines.
The term computer language is sometimes used interchangeably with "programming language". However, usage of these terms varies among authors.
In one usage, programming languages are described as a subset of computer languages. Similarly, the term "computer language" may be used in contrast to the term "programming language" to describe languages used in computing but not considered programming languages. Most practical programming languages are Turing complete, and as such are equivalent in what programs they can compute.
Another usage regards programming languages as theoretical constructs for programming abstract machines and computer languages as the subset thereof that runs on physical computers, which have finite hardware resources. John C. Reynolds emphasizes that formal specification languages are just as much programming languages as are the languages intended for execution. He also argues that textual and even graphical input formats that affect the behavior of a computer are programming languages, despite the fact they are commonly not Turing-complete, and remarks that ignorance of programming language concepts is the reason for many flaws in input formats.
== History ==
=== Early developments ===
The first programmable computers were invented at the end of the 1940s, and with them, the first programming languages. The earliest computers were programmed in first-generation programming languages (1GLs), machine language (simple instructions that could be directly executed by the processor). This code was very difficult to debug and was not portable between different computer systems. In order to improve the ease of programming, assembly languages (or second-generation programming languages—2GLs) were invented, diverging from the machine language to make programs easier to understand for humans, although they did not increase portability.
Initially, hardware resources were scarce and expensive, while human resources were cheaper. Therefore, cumbersome languages that were time-consuming to use, but were closer to the hardware for higher efficiency were favored. The introduction of high-level programming languages (third-generation programming languages—3GLs)—revolutionized programming. These languages abstracted away the details of the hardware, instead being designed to express
|
https://en.wikipedia.org/wiki/Programming_language
|
C (pronounced – like the letter c) is a general-purpose programming language. It was created in the 1970s by Dennis Ritchie and remains very widely used and influential. By design, C's features cleanly reflect the capabilities of the targeted CPUs. It has found lasting use in operating systems code (especially in kernels), device drivers, and protocol stacks, but its use in application software has been decreasing. C is commonly used on computer architectures that range from the largest supercomputers to the smallest microcontrollers and embedded systems.
A successor to the programming language B, C was originally developed at Bell Labs by Ritchie between 1972 and 1973 to construct utilities running on Unix. It was applied to re-implementing the kernel of the Unix operating system. During the 1980s, C gradually gained popularity. It has become one of the most widely used programming languages, with C compilers available for practically all modern computer architectures and operating systems. The book The C Programming Language, co-authored by the original language designer, served for many years as the de facto standard for the language. C has been standardized since 1989 by the American National Standards Institute (ANSI) and, subsequently, jointly by the International Organization for Standardization (ISO) and the International Electrotechnical Commission (IEC).
C is an imperative procedural language, supporting structured programming, lexical variable scope, and recursion, with a static type system. It was designed to be compiled to provide low-level access to memory and language constructs that map efficiently to machine instructions, all with minimal runtime support. Despite its low-level capabilities, the language was designed to encourage cross-platform programming. A standards-compliant C program written with portability in mind can be compiled for a wide variety of computer platforms and operating systems with few changes to its source code.
Since 2000, C has consistently ranked among the top four languages in the TIOBE index, a measure of the popularity of programming languages.
== Overview ==
C is an imperative, procedural language in the ALGOL tradition. It has a static type system. In C, all executable code is contained within subroutines (also called "functions", though not in the sense of functional programming). Function parameters are passed by value, although arrays are passed as pointers, i.e. the address of the first item in the array. Pass-by-reference is simulated in C by explicitly passing pointers to the thing being referenced.
C program source text is free-form code. Semicolons terminate statements, while curly braces are used to group statements into blocks.
The C language also exhibits the following characteristics:
The language has a small, fixed number of keywords, including a full set of control flow primitives: if/else, for, do/while, while, and switch. User-defined names are not distinguished from keywords by any kind of sigil.
It has a large number of arithmetic, bitwise, and logic operators: +,+=,++,&,||, etc.
More than one assignment may be performed in a single statement.
Functions:
Function return values can be ignored, when not needed.
Function and data pointers permit ad hoc run-time polymorphism.
Functions may not be defined within the lexical scope of other functions.
Variables may be defined within a function, with scope.
A function may call itself, so recursion is supported.
Data typing is static, but weakly enforced; all data has a type, but implicit conversions are possible.
User-defined (typedef) and compound types are possible.
Heterogeneous aggregate data types (struct) allow related data elements to be accessed and assigned as a unit. The contents of whole structs cannot be compared using a single built-in operator (the elements must be compared individually).
Union is a structure with overlapping members; it allows multiple data types to share the same memory location.
A
|
https://en.wikipedia.org/wiki/C_(programming_language)
|
In computer programming, a programming idiom, code idiom or simply idiom is a code fragment having a semantic role which recurs frequently across software projects. It often expresses a special feature of a recurring construct in one or more programming languages, frameworks or libraries. This definition is rooted in the linguistic definition of "idiom".
The idiom can be seen by developers as an action on a programming concept underlying a pattern in code, which is represented in implementation by contiguous or scattered code snippets. Generally speaking, a programming idiom's semantic role is a natural language expression of a simple task, algorithm, or data structure that is not a built-in feature in the programming language being used, or, conversely, the use of an unusual or notable feature that is built into a programming language.
Knowing the idioms associated with a programming language and how to use them is an important part of gaining fluency in that language. It also helps to transfer knowledge in the form of analogies from one language or framework to another. Such idiomatic knowledge is widely used in crowdsourced repositories to help developers overcome programming barriers.
Mapping code idioms to idiosyncrasies can be a helpful way to navigate the tradeoffs between generalization and specificity. By identifying common patterns and idioms, developers can create mental models and schemata that help them quickly understand and navigate new code. Furthermore, by mapping these idioms to idiosyncrasies and specific use cases, developers can ensure that they are applying the correct approach and not overgeneralizing it.
One way to do this is by creating a reference or documentation that maps common idioms to specific use cases, highlighting where they may need to be adapted or modified to fit a particular project or development team. This can help ensure that developers are working with a shared understanding of best practices and can make informed decisions about when to use established idioms and when to adapt them to fit their specific needs.
A common misconception is to use the adverbial or adjectival form of the term as "using a programming language in a typical way", which really refers to a idiosyncrasy. An idiom implies the semantics of some code in a programming language has similarities to other languages or frameworks. For example, an idiosyncratic way to manage dynamic memory in C would be to use the C standard library functions malloc and free, whereas idiomatic refers to manual memory management as recurring semantic role that can be achieved with code fragments malloc in C, or pointer = new type [number_of_elements] in C++. In both cases, the semantics of the code are intelligible to developers familiar with C or C++, once the idiomatic or idiosyncratic rationale is exposed to them. However, while idiomatic rationale is often general to the programming domain, idiosyncratic rationale is frequently tied to specific API terminology.
== Examples ==
=== Printing Hello World ===
One of the most common starting points to learn to program or notice the syntax differences between a known language and a new one.
It has several implementations, among them the code fragments for C++:
For Java:
=== Inserting an element in an array ===
This idiom helps developers understand how to manipulate collections in a given language, particularly inserting an element x at a position i in a list s and moving the elements to its right.
Code fragments:
For Python:
For JavaScript:
For Perl:
== See also ==
Algorithmic skeleton
Embedded SQL
Idiom
== References ==
== External links ==
programming-idioms.org shows short idioms implementations in most mainstream languages.
C++ programming idioms from Wikibooks.
|
https://en.wikipedia.org/wiki/Programming_idiom
|
In computer science, reflective programming or reflection is the ability of a process to examine, introspect, and modify its own structure and behavior.
== Historical background ==
The earliest computers were programmed in their native assembly languages, which were inherently reflective, as these original architectures could be programmed by defining instructions as data and using self-modifying code. As the bulk of programming moved to higher-level compiled languages such as ALGOL, COBOL, Fortran, Pascal, and C, this reflective ability largely disappeared until new programming languages with reflection built into their type systems appeared.
Brian Cantwell Smith's 1982 doctoral dissertation introduced the notion of computational reflection in procedural programming languages and the notion of the meta-circular interpreter as a component of 3-Lisp.
== Uses ==
Reflection helps programmers make generic software libraries to display data, process different formats of data, perform serialization and deserialization of data for communication, or do bundling and unbundling of data for containers or bursts of communication.
Effective use of reflection almost always requires a plan: A design framework, encoding description, object library, a map of a database or entity relations.
Reflection makes a language more suited to network-oriented code. For example, it assists languages such as Java to operate well in networks by enabling libraries for serialization, bundling and varying data formats. Languages without reflection such as C are required to use auxiliary compilers for tasks like Abstract Syntax Notation to produce code for serialization and bundling.
Reflection can be used for observing and modifying program execution at runtime. A reflection-oriented program component can monitor the execution of an enclosure of code and can modify itself according to a desired goal of that enclosure. This is typically accomplished by dynamically assigning program code at runtime.
In object-oriented programming languages such as Java, reflection allows inspection of classes, interfaces, fields and methods at runtime without knowing the names of the interfaces, fields, methods at compile time. It also allows instantiation of new objects and invocation of methods.
Reflection is often used as part of software testing, such as for the runtime creation/instantiation of mock objects.
Reflection is also a key strategy for metaprogramming.
In some object-oriented programming languages such as C# and Java, reflection can be used to bypass member accessibility rules. For C#-properties this can be achieved by writing directly onto the (usually invisible) backing field of a non-public property. It is also possible to find non-public methods of classes and types and manually invoke them. This works for project-internal files as well as external libraries such as .NET's assemblies and Java's archives.
== Implementation ==
A language that supports reflection provides a number of features available at runtime that would otherwise be difficult to accomplish in a lower-level language. Some of these features are the abilities to:
Discover and modify source-code constructions (such as code blocks, classes, methods, protocols, etc.) as first-class objects at runtime.
Convert a string matching the symbolic name of a class or function into a reference to or invocation of that class or function.
Evaluate a string as if it were a source-code statement at runtime.
Create a new interpreter for the language's bytecode to give a new meaning or purpose for a programming construct.
These features can be implemented in different ways. In MOO, reflection forms a natural part of everyday programming idiom. When verbs (methods) are called, various variables such as verb (the name of the verb being called) and this (the object on which the verb is called) are populated to give the context of the call. Security is typically managed by accessing the caller stack programmat
|
https://en.wikipedia.org/wiki/Reflective_programming
|
In computer science, extensible programming is a style of computer programming that focuses on mechanisms to extend the programming language, compiler, and runtime system (environment). Extensible programming languages, supporting this style of programming, were an active area of work in the 1960s, but the movement was marginalized in the 1970s. Extensible programming has become a topic of renewed interest in the 21st century.
== Historical movement ==
The first paper usually associated with the extensible programming language movement is M. Douglas McIlroy's 1960 paper on macros for high-level programming languages. Another early description of the principle of extensibility occurs in Brooker and Morris's 1960 paper on the compiler-compiler. The peak of the movement was marked by two academic symposia, in 1969 and 1971. By 1975, a survey article on the movement by Thomas A. Standish was essentially a post mortem. The Forth was an exception, but it went essentially unnoticed.
=== Character of the historical movement ===
As typically envisioned, an extensible language consisted of a base language providing elementary computing facilities, and a metalanguage able to modify the base language. A program then consisted of metalanguage modifications and code in the modified base language.
The most prominent language-extension technique used in the movement was macro definition. Grammar modification was also closely associated with the movement, resulting in the eventual development of adaptive grammar formalisms. The Lisp language community remained separate from the extensible language community, apparently because, as one researcher observed,
any programming language in which programs and data are essentially interchangeable can be regarded as an extendible [sic] language. ... this can be seen very easily from the fact that Lisp has been used as an extendible language for years.
At the 1969 conference, Simula was presented as an extensible language.
Standish described three classes of language extension, which he named paraphrase, orthophrase, and metaphrase (otherwise paraphrase and metaphrase being translation terms).
Paraphrase defines a facility by showing how to exchange it for something formerly defined (or to be defined). As examples, he mentions macro definitions, ordinary procedure definitions, grammatical extensions, data definitions, operator definitions, and control structure extensions.
Orthophrase adds features to a language that could not be achieved using the base language, such as adding an input/output (I/O) system to a base language formerly with no I/O primitives. Extensions must be understood as orthophrase relative to some given base language, since a feature not defined in terms of the base language must be defined in terms of some other language. This corresponds to the modern notion of plug-ins.
Metaphrase modifies the interpretation rules used for pre-existing expressions. This corresponds to the modern notion of reflective programming (reflection).
=== Death of the historical movement ===
Standish attributed the failure of the extensibility movement to the difficulty of programming successive extensions. A programmer might build a first shell of macros around a base language. Then, if a second shell of macros is built around that, any subsequent programmer must be intimately familiar with both the base language, and the first shell. A third shell would require familiarity with the base and both the first and second shells, and so on. Shielding a programmer from lower-level details is the intent of the abstraction movement that supplanted the extensibility movement.
Despite the earlier presentation of Simula as extensible, by 1975, Standish's survey does not seem in practice to have included the newer abstraction-based technologies (though he used a very general definition of extensibility that technically could have included them). A 1978 history of programming abstraction from the invention of t
|
https://en.wikipedia.org/wiki/Extensible_programming
|
In computer science, functional programming is a programming paradigm where programs are constructed by applying and composing functions. It is a declarative programming paradigm in which function definitions are trees of expressions that map values to other values, rather than a sequence of imperative statements which update the running state of the program.
In functional programming, functions are treated as first-class citizens, meaning that they can be bound to names (including local identifiers), passed as arguments, and returned from other functions, just as any other data type can. This allows programs to be written in a declarative and composable style, where small functions are combined in a modular manner.
Functional programming is sometimes treated as synonymous with purely functional programming, a subset of functional programming that treats all functions as deterministic mathematical functions, or pure functions. When a pure function is called with some given arguments, it will always return the same result, and cannot be affected by any mutable state or other side effects. This is in contrast with impure procedures, common in imperative programming, which can have side effects (such as modifying the program's state or taking input from a user). Proponents of purely functional programming claim that by restricting side effects, programs can have fewer bugs, be easier to debug and test, and be more suited to formal verification.
Functional programming has its roots in academia, evolving from the lambda calculus, a formal system of computation based only on functions. Functional programming has historically been less popular than imperative programming, but many functional languages are seeing use today in industry and education, including Common Lisp, Scheme, Clojure, Wolfram Language, Racket, Erlang, Elixir, OCaml, Haskell, and F#. Lean is a functional programming language commonly used for verifying mathematical theorems. Functional programming is also key to some languages that have found success in specific domains, like JavaScript in the Web, R in statistics, J, K and Q in financial analysis, and XQuery/XSLT for XML. Domain-specific declarative languages like SQL and Lex/Yacc use some elements of functional programming, such as not allowing mutable values. In addition, many other programming languages support programming in a functional style or have implemented features from functional programming, such as C++11, C#, Kotlin, Perl, PHP, Python, Go, Rust, Raku, Scala, and Java (since Java 8).
== History ==
The lambda calculus, developed in the 1930s by Alonzo Church, is a formal system of computation built from function application. In 1937 Alan Turing proved that the lambda calculus and Turing machines are equivalent models of computation, showing that the lambda calculus is Turing complete. Lambda calculus forms the basis of all functional programming languages. An equivalent theoretical formulation, combinatory logic, was developed by Moses Schönfinkel and Haskell Curry in the 1920s and 1930s.
Church later developed a weaker system, the simply typed lambda calculus, which extended the lambda calculus by assigning a data type to all terms. This forms the basis for statically typed functional programming.
The first high-level functional programming language, Lisp, was developed in the late 1950s for the IBM 700/7000 series of scientific computers by John McCarthy while at Massachusetts Institute of Technology (MIT). Lisp functions were defined using Church's lambda notation, extended with a label construct to allow recursive functions. Lisp first introduced many paradigmatic features of functional programming, though early Lisps were multi-paradigm languages, and incorporated support for numerous programming styles as new paradigms evolved. Later dialects, such as Scheme and Clojure, and offshoots such as Dylan and Julia, sought to simplify and rationalise Lisp around a cleanly functional core, while Common
|
https://en.wikipedia.org/wiki/Functional_programming
|
Inductive programming (IP) is a special area of automatic programming, covering research from artificial intelligence and programming, which addresses learning of typically declarative (logic or functional) and often recursive programs from incomplete specifications, such as input/output examples or constraints.
Depending on the programming language used, there are several kinds of inductive programming. Inductive functional programming, which uses functional programming languages such as Lisp or Haskell, and most especially inductive logic programming, which uses logic programming languages such as Prolog and other logical representations such as description logics, have been more prominent, but other (programming) language paradigms have also been used, such as constraint programming or probabilistic programming.
== Definition ==
Inductive programming incorporates all approaches which are concerned with learning programs or algorithms from incomplete (formal) specifications. Possible inputs in an IP system are a set of training inputs and corresponding outputs or an output evaluation function, describing the desired behavior of the intended program, traces or action sequences which describe the process of calculating specific outputs, constraints for the program to be induced concerning its time efficiency or its complexity, various kinds of background knowledge such as standard data types, predefined functions to be used, program schemes or templates describing the data flow of the intended program, heuristics for guiding the search for a solution or other biases.
Output of an IP system is a program in some arbitrary programming language containing conditionals and loop or recursive control structures, or any other kind of Turing-complete representation language.
In many applications the output program must be correct with respect to the examples and partial specification, and this leads to the consideration of inductive programming as a special area inside automatic programming or program synthesis, usually opposed to 'deductive' program synthesis, where the specification is usually complete.
In other cases, inductive programming is seen as a more general area where any declarative programming or representation language can be used and we may even have some degree of error in the examples, as in general machine learning, the more specific area of structure mining or the area of symbolic artificial intelligence. A distinctive feature is the number of examples or partial specification needed. Typically, inductive programming techniques can learn from just a few examples.
The diversity of inductive programming usually comes from the applications and the languages that are used: apart from logic programming and functional programming, other programming paradigms and representation languages have been used or suggested in inductive programming, such as functional logic programming, constraint programming, probabilistic programming, abductive logic programming, modal logic, action languages, agent languages and many types of imperative languages.
== History ==
Research on the inductive synthesis of recursive functional programs started in the early 1970s and was brought onto firm theoretical foundations with the seminal THESIS system of Summers and work of Biermann.
These approaches were split into two phases: first, input-output examples are transformed into non-recursive programs (traces) using a small set of basic operators; second, regularities in the traces are searched for and used to fold them into a recursive program. The main results until the mid-1980s are surveyed by Smith. Due to limited progress with respect to the range of programs that could be synthesized, research activities decreased significantly in the next decade.
The advent of logic programming brought a new elan but also a new direction in the early 1980s, especially due to the MIS system of Shapiro eventually spawning the new field of inductive log
|
https://en.wikipedia.org/wiki/Inductive_programming
|
Extreme programming (XP) is a software development methodology intended to improve software quality and responsiveness to changing customer requirements. As a type of agile software development, it advocates frequent releases in short development cycles, intended to improve productivity and introduce checkpoints at which new customer requirements can be adopted.
Other elements of extreme programming include programming in pairs or doing extensive code review, unit testing of all code, not programming features until they are actually needed, a flat management structure, code simplicity and clarity, expecting changes in the customer's requirements as time passes and the problem is better understood, and frequent communication with the customer and among programmers. The methodology takes its name from the idea that the beneficial elements of traditional software engineering practices are taken to "extreme" levels. As an example, code reviews are considered a beneficial practice; taken to the extreme, code can be reviewed continuously (i.e. the practice of pair programming).
== History ==
Kent Beck developed extreme programming during his work on the Chrysler Comprehensive Compensation System (C3) payroll project. Beck became the C3 project leader in March 1996. He began to refine the development methodology used in the project and wrote a book on the methodology (Extreme Programming Explained, published in October 1999). Chrysler cancelled the C3 project in February 2000, after seven years, when Daimler-Benz acquired the company. Ward Cunningham was another major influence on XP.
Many extreme-programming practices have been around for some time; the methodology takes "best practices" to extreme levels. For example, the "practice of test-first development, planning and writing tests before each micro-increment" was used as early as NASA's Project Mercury, in the early 1960s. To shorten the total development time, some formal test documents (such as for acceptance testing) have been developed in parallel with (or shortly before) the software being ready for testing. A NASA independent test group can write the test procedures, based on formal requirements and logical limits, before programmers write the software and integrate it with the hardware. XP takes this concept to the extreme level, writing automated tests (sometimes inside software modules) which validate the operation of even small sections of software coding, rather than only testing the larger features.
=== Origins ===
Two major influences shaped software development in the 1990s:
Internally, object-oriented programming replaced procedural programming as the programming paradigm favored by some developers.
Externally, the rise of the Internet and the dot-com boom emphasized speed-to-market and company growth as competitive business factors.
Rapidly changing requirements demanded shorter product life-cycles, and often clashed with traditional methods of software development.
The Chrysler Comprehensive Compensation System (C3) started in order to determine the best way to use object technologies, using the payroll systems at Chrysler as the object of research, with Smalltalk as the language and GemStone as the data access layer. Chrysler brought in Kent Beck, a prominent Smalltalk practitioner, to do performance tuning on the system, but his role expanded as he noted several problems with the development process. He took this opportunity to propose and implement some changes in development practices - based on his work with his frequent collaborator, Ward Cunningham. Beck describes the early conception of the methods:
The first time I was asked to lead a team, I asked them to do a little bit of the things I thought were sensible, like testing and reviews. The second time there was a lot more on the line. I thought, "Damn the torpedoes, at least this will make a good article," [and] asked the team to crank up all the knobs to 10 on the things I thought were essent
|
https://en.wikipedia.org/wiki/Extreme_programming
|
Defensive programming is a form of defensive design intended to develop programs that are capable of detecting potential security abnormalities and make predetermined responses. It ensures the continuing function of a piece of software under unforeseen circumstances. Defensive programming practices are often used where high availability, safety, or security is needed.
Defensive programming is an approach to improve software and source code, in terms of:
General quality – reducing the number of software bugs and problems.
Making the source code comprehensible – the source code should be readable and understandable so it is approved in a code audit.
Making the software behave in a predictable manner despite unexpected inputs or user actions.
Overly defensive programming, however, may safeguard against errors that will never be encountered, thus incurring run-time and maintenance costs.
== Secure programming ==
Secure programming is the subset of defensive programming concerned with computer security. Security is the concern, not necessarily safety or availability (the software may be allowed to fail in certain ways). As with all kinds of defensive programming, avoiding bugs is a primary objective; however, the motivation is not as much to reduce the likelihood of failure in normal operation (as if safety were the concern), but to reduce the attack surface – the programmer must assume that the software might be misused actively to reveal bugs, and that bugs could be exploited maliciously.
The function will result in undefined behavior when the input is over 1000 characters. Some programmers may not feel that this is a problem, supposing that no user will enter such a long input. This particular bug demonstrates a vulnerability which enables buffer overflow exploits. Here is a solution to this example:
== Offensive programming ==
Offensive programming is a category of defensive programming, with the added emphasis that certain errors should not be handled defensively. In this practice, only errors from outside the program's control are to be handled (such as user input); the software itself, as well as data from within the program's line of defense, are to be trusted in this methodology.
=== Trusting internal data validity ===
Overly defensive programming
Offensive programming
=== Trusting software components ===
Overly defensive programming
Offensive programming
== Techniques ==
Here are some defensive programming techniques:
=== Intelligent source code reuse ===
If existing code is tested and known to work, reusing it may reduce the chance of bugs being introduced.
However, reusing code is not always good practice. Reuse of existing code, especially when widely distributed, can allow for exploits to be created that target a wider audience than would otherwise be possible and brings with it all the security and vulnerabilities of the reused code.
When considering using existing source code, a quick review of the modules(sub-sections such as classes or functions) will help eliminate or make the developer aware of any potential vulnerabilities and ensure it is suitable to use in the project.
==== Legacy problems ====
Before reusing old source code, libraries, APIs, configurations and so forth, it must be considered if the old work is valid for reuse, or if it is likely to be prone to legacy problems.
Legacy problems are problems inherent when old designs are expected to work with today's requirements, especially when the old designs were not developed or tested with those requirements in mind.
Many software products have experienced problems with old legacy source code; for example:
Legacy code may not have been designed under a defensive programming initiative, and might therefore be of much lower quality than newly designed source code.
Legacy code may have been written and tested under conditions which no longer apply. The old quality assurance tests may have no validity any more.
Example 1: legacy code may
|
https://en.wikipedia.org/wiki/Defensive_programming
|
Ajax (also AJAX ; short for "asynchronous JavaScript and XML") is a set of web development techniques that uses various web technologies on the client-side to create asynchronous web applications. With Ajax, web applications can send and retrieve data from a server asynchronously (in the background) without interfering with the display and behaviour of the existing page. By decoupling the data interchange layer from the presentation layer, Ajax allows web pages and, by extension, web applications, to change content dynamically without the need to reload the entire page. In practice, modern implementations commonly utilize JSON instead of XML.
Ajax is not a technology, but rather a programming pattern. HTML and CSS can be used in combination to mark up and style information. The webpage can be modified by JavaScript to dynamically display (and allow the user to interact with) the new information. The built-in XMLHttpRequest object is used to execute Ajax on webpages, allowing websites to load content onto the screen without refreshing the page. Ajax is not a new technology, nor is it a new language. Instead, it is existing technologies used in a new way.
== History ==
In the early-to-mid 1990s, most Websites were based on complete HTML pages. Each user action required a complete new page to be loaded from the server. This process was inefficient, as reflected by the user experience: all page content disappeared, then the new page appeared. Each time the browser reloaded a page because of a partial change, all the content had to be re-sent, even though only some of the information had changed. This placed additional load on the server and made bandwidth a limiting factor in performance.
In 1996, the iframe tag was introduced by Internet Explorer; like the object element, it can load a part of the web page asynchronously. In 1998, the Microsoft Outlook Web Access team developed the concept behind the XMLHttpRequest scripting object. It appeared as XMLHTTP in the second version of the MSXML library, which shipped with Internet Explorer 5.0 in March 1999.
The functionality of the Windows XMLHTTP ActiveX control in IE 5 was later implemented by Mozilla Firefox, Safari, Opera, Google Chrome, and other browsers as the XMLHttpRequest JavaScript object. Microsoft adopted the native XMLHttpRequest model as of Internet Explorer 7. The ActiveX version is still supported in Internet Explorer and on "Internet Explorer mode" in Microsoft Edge. The utility of these background HTTP requests and asynchronous Web technologies remained fairly obscure until it started appearing in large scale online applications such as Outlook Web Access (2000) and Oddpost (2002).
Google made a wide deployment of standards-compliant, cross browser Ajax with Gmail (2004) and Google Maps (2005). In October 2004 Kayak.com's public beta release was among the first large-scale e-commerce uses of what their developers at that time called "the xml http thing". This increased interest in Ajax among web program developers.
The term AJAX was publicly used on 18 February 2005 by Jesse James Garrett in an article titled Ajax: A New Approach to Web Applications, based on techniques used on Google pages.
On 5 April 2006, the World Wide Web Consortium (W3C) released the first draft specification for the XMLHttpRequest object in an attempt to create an official Web standard.
The latest draft of the XMLHttpRequest object was published on 6 October 2016, and the XMLHttpRequest specification is now a living standard.
== Technologies ==
The term Ajax has come to represent a broad group of Web technologies that can be used to implement a Web application that communicates with a server in the background, without interfering with the current state of the page. In the article that coined the term Ajax, Jesse James Garrett explained that the following technologies are incorporated:
HTML (or XHTML) and CSS for presentation
The Document Object Model (DOM) for dynamic display of and in
|
https://en.wikipedia.org/wiki/Ajax_(programming)
|
In computer science, imperative programming is a programming paradigm of software that uses statements that change a program's state. In much the same way that the imperative mood in natural languages expresses commands, an imperative program consists of commands for the computer to perform. Imperative programming focuses on describing how a program operates step by step (generally order of the steps being determined in source code by the placement of statements one below the other), rather than on high-level descriptions of its expected results.
The term is often used in contrast to declarative programming, which focuses on what the program should accomplish without specifying all the details of how the program should achieve the result.
== Procedural programming ==
Procedural programming is a type of imperative programming in which the program is built from one or more procedures (also termed subroutines or functions). The terms are often used as synonyms, but the use of procedures has a dramatic effect on how imperative programs appear and how they are constructed. Heavy procedural programming, in which state changes are localized to procedures or restricted to explicit arguments and returns from procedures, is a form of structured programming. Since the 1960s, structured programming and modular programming in general have been promoted as techniques to improve the maintainability and overall quality of imperative programs. The concepts behind object-oriented programming attempt to extend this approach.
Procedural programming could be considered a step toward declarative programming. A programmer can often tell, simply by looking at the names, arguments, and return types of procedures (and related comments), what a particular procedure is supposed to do, without necessarily looking at the details of how it achieves its result. At the same time, a complete program is still imperative since it fixes the statements to be executed and their order of execution to a large extent.
== Rationale and foundations of imperative programming ==
The programming paradigm used to build programs for almost all computers typically follows an imperative model. Digital computer hardware is designed to execute machine code, which is native to the computer and is usually written in the imperative style, although low-level compilers and interpreters using other paradigms exist for some architectures such as lisp machines.
From this low-level perspective, the program state is defined by the contents of memory, and the statements are instructions in the native machine language of the computer. Higher-level imperative languages use variables and more complex statements, but still follow the same paradigm. Recipes and process checklists, while not computer programs, are also familiar concepts that are similar in style to imperative programming; each step is an instruction, and the physical world holds the state. Since the basic ideas of imperative programming are both conceptually familiar and directly embodied in the hardware, most computer languages are in the imperative style.
Assignment statements, in imperative paradigm, perform an operation on information located in memory and store the results in memory for later use. High-level imperative languages, in addition, permit the evaluation of complex expressions, which may consist of a combination of arithmetic operations and function evaluations, and the assignment of the resulting value to memory. Looping statements (as in while loops, do while loops, and for loops) allow a sequence of statements to be executed multiple times. Loops can either execute the statements they contain a predefined number of times, or they can execute them repeatedly until some condition is met. Conditional branching statements allow a sequence of statements to be executed only if some condition is met. Otherwise, the statements are skipped and the execution sequence continues from the statement following them. Uncon
|
https://en.wikipedia.org/wiki/Imperative_programming
|
Java is a high-level, general-purpose, memory-safe, object-oriented programming language. It is intended to let programmers write once, run anywhere (WORA), meaning that compiled Java code can run on all platforms that support Java without the need to recompile. Java applications are typically compiled to bytecode that can run on any Java virtual machine (JVM) regardless of the underlying computer architecture. The syntax of Java is similar to C and C++, but has fewer low-level facilities than either of them. The Java runtime provides dynamic capabilities (such as reflection and runtime code modification) that are typically not available in traditional compiled languages.
Java gained popularity shortly after its release, and has been a popular programming language since then. Java was the third most popular programming language in 2022 according to GitHub. Although still widely popular, there has been a gradual decline in use of Java in recent years with other languages using JVM gaining popularity.
Java was designed by James Gosling at Sun Microsystems. It was released in May 1995 as a core component of Sun's Java platform. The original and reference implementation Java compilers, virtual machines, and class libraries were released by Sun under proprietary licenses. As of May 2007, in compliance with the specifications of the Java Community Process, Sun had relicensed most of its Java technologies under the GPL-2.0-only license. Oracle, which bought Sun in 2010, offers its own HotSpot Java Virtual Machine. However, the official reference implementation is the OpenJDK JVM, which is open-source software used by most developers and is the default JVM for almost all Linux distributions.
Java 24 is the version current as of March 2025. Java 8, 11, 17, and 21 are long-term support versions still under maintenance.
== History ==
James Gosling, Mike Sheridan, and Patrick Naughton initiated the Java language project in June 1991. Java was originally designed for interactive television, but it was too advanced for the digital cable television industry at the time. The language was initially called Oak after an oak tree that stood outside Gosling's office. Later the project went by the name Green and was finally renamed Java, from Java coffee, a type of coffee from Indonesia. Gosling designed Java with a C/C++-style syntax that system and application programmers would find familiar.
Sun Microsystems released the first public implementation as Java 1.0 in 1996. It promised write once, run anywhere (WORA) functionality, providing no-cost run-times on popular platforms. Fairly secure and featuring configurable security, it allowed network- and file-access restrictions. Major web browsers soon incorporated the ability to run Java applets within web pages, and Java quickly became popular. The Java 1.0 compiler was re-written in Java by Arthur van Hoff to comply strictly with the Java 1.0 language specification. With the advent of Java 2 (released initially as J2SE 1.2 in December 1998 – 1999), new versions had multiple configurations built for different types of platforms. J2EE included technologies and APIs for enterprise applications typically run in server environments, while J2ME featured APIs optimized for mobile applications. The desktop version was renamed J2SE. In 2006, for marketing purposes, Sun renamed new J2 versions as Java EE, Java ME, and Java SE, respectively.
In 1997, Sun Microsystems approached the ISO/IEC JTC 1 standards body and later the Ecma International to formalize Java, but it soon withdrew from the process. Java remains a de facto standard, controlled through the Java Community Process. At one time, Sun made most of its Java implementations available without charge, despite their proprietary software status. Sun generated revenue from Java through the selling of licenses for specialized products such as the Java Enterprise System.
On November 13, 2006, Sun released much of its Java virtual machine (JVM) as free
|
https://en.wikipedia.org/wiki/Java_(programming_language)
|
In computer science, array programming refers to solutions that allow the application of operations to an entire set of values at once. Such solutions are commonly used in scientific and engineering settings.
Modern programming languages that support array programming (also known as vector or multidimensional languages) have been engineered specifically to generalize operations on scalars to apply transparently to vectors, matrices, and higher-dimensional arrays. These include APL, J, Fortran, MATLAB, Analytica, Octave, R, Cilk Plus, Julia, Perl Data Language (PDL), Raku (programming language). In these languages, an operation that operates on entire arrays can be called a vectorized operation, regardless of whether it is executed on a vector processor, which implements vector instructions. Array programming primitives concisely express broad ideas about data manipulation. The level of concision can be dramatic in certain cases: it is not uncommon to find array programming language one-liners that require several pages of object-oriented code.
== Concepts of array ==
The fundamental idea behind array programming is that operations apply at once to an entire set of values. This makes it a high-level programming model as it allows the programmer to think and operate on whole aggregates of data, without having to resort to explicit loops of individual scalar operations.
Kenneth E. Iverson described the rationale behind array programming (actually referring to APL) as follows:
most programming languages are decidedly inferior to mathematical notation and are little used as tools of thought in ways that would be considered significant by, say, an applied mathematician.
The thesis is that the advantages of executability and universality found in programming languages can be effectively combined, in a single coherent language, with the advantages offered by mathematical notation. it is important to distinguish the difficulty of describing and of learning a piece of notation from the difficulty of mastering its implications. For example, learning the rules for computing a matrix product is easy, but a mastery of its implications (such as its associativity, its distributivity over addition, and its ability to represent linear functions and geometric operations) is a different and much more difficult matter.
Indeed, the very suggestiveness of a notation may make it seem harder to learn because of the many properties it suggests for explorations.
[...]
Users of computers and programming languages are often concerned primarily with the efficiency of execution of algorithms, and might, therefore, summarily dismiss many of the algorithms presented here. Such dismissal would be short-sighted since a clear statement of an algorithm can usually be used as a basis from which one may easily derive a more efficient algorithm.
The basis behind array programming and thinking is to find and exploit the properties of data where individual elements are similar or adjacent. Unlike object orientation which implicitly breaks down data to its constituent parts (or scalar quantities), array orientation looks to group data and apply a uniform handling.
Function rank is an important concept to array programming languages in general, by analogy to tensor rank in mathematics: functions that operate on data may be classified by the number of dimensions they act on. Ordinary multiplication, for example, is a scalar ranked function because it operates on zero-dimensional data (individual numbers). The cross product operation is an example of a vector rank function because it operates on vectors, not scalars. Matrix multiplication is an example of a 2-rank function, because it operates on 2-dimensional objects (matrices). Collapse operators reduce the dimensionality of an input data array by one or more dimensions. For example, summing over elements collapses the input array by 1 dimension.
== Uses ==
Array programming is very well suited to implicit parall
|
https://en.wikipedia.org/wiki/Array_programming
|
Python is a high-level, general-purpose programming language. Its design philosophy emphasizes code readability with the use of significant indentation.
Python is dynamically type-checked and garbage-collected. It supports multiple programming paradigms, including structured (particularly procedural), object-oriented and functional programming. It is often described as a "batteries included" language due to its comprehensive standard library.
Guido van Rossum began working on Python in the late 1980s as a successor to the ABC programming language, and he first released it in 1991 as Python 0.9.0. Python 2.0 was released in 2000. Python 3.0, released in 2008, was a major revision not completely backward-compatible with earlier versions. Python 2.7.18, released in 2020, was the last release of Python 2.
Python consistently ranks as one of the most popular programming languages, and it has gained widespread use in the machine learning community.
== History ==
Python was conceived in the late 1980s by Guido van Rossum at Centrum Wiskunde & Informatica (CWI) in the Netherlands; it was conceived as a successor to the ABC programming language, which was inspired by SETL, capable of exception handling and interfacing with the Amoeba operating system. Python implementation began in December 1989. Van Rossum assumed sole responsibility for the project, as the lead developer, until 12 July 2018, when he announced his "permanent vacation" from responsibilities as Python's "benevolent dictator for life" (BDFL); this title was bestowed on him by the Python community to reflect his long-term commitment as the project's chief decision-maker. (He has since come out of retirement and is self-titled "BDFL-emeritus".) In January 2019, active Python core developers elected a five-member Steering Council to lead the project.
The name Python is said to derive from the British comedy series Monty Python's Flying Circus.
Python 2.0 was released on 16 October 2000, with many major new features such as list comprehensions, cycle-detecting garbage collection, reference counting, and Unicode support. Python 2.7's end-of-life was initially set for 2015, and then postponed to 2020 out of concern that a large body of existing code could not easily be forward-ported to Python 3. It no longer receives security patches or updates. While Python 2.7 and older versions are officially unsupported, a different unofficial Python implementation, PyPy, continues to support Python 2, i.e., "2.7.18+" (plus 3.10), with the plus signifying (at least some) "backported security updates".
Python 3.0 was released on 3 December 2008, with some new semantics and changed syntax. At least every Python release since (the now unsupported) 3.5 has added some syntax to the language; a few later releases have removed outdated modules and have changed semantics, at least in a minor way.
As of 8 April 2025, Python 3.13.3 is the latest stable release (it's highly recommended to upgrade to it, or upgrade any other older 3.x release). This version currently receives full bug-fix and security updates, while Python 3.12—released in October 2023—had active bug-fix support only until April 2025, and since then only security fixes. Python 3.9 is the oldest supported version of Python (albeit in the 'security support' phase), because Python 3.8 has become an end-of-life product. Starting with Python 3.13, it and later versions receive two years of full support (which has increased from one and a half years), followed by three years of security support; this is the same total duration of support as previously.
Security updates were expedited in 2021 and again twice in 2022. More issues were fixed in 2023 and in September 2024 (for Python versions 3.8.20 through 3.12.6)—all versions (including 2.7) had been insecure because of issues leading to possible remote code execution and web-cache poisoning.
Python 3.10 added the | union type operator and added structural pattern matching capability t
|
https://en.wikipedia.org/wiki/Python_(programming_language)
|
Generic programming is a style of computer programming in which algorithms are written in terms of data types to-be-specified-later that are then instantiated when needed for specific types provided as parameters. This approach, pioneered in the programming language ML in 1973, permits writing common functions or data types that differ only in the set of types on which they operate when used, thus reducing duplicate code.
Generic programming was introduced to the mainstream with Ada in 1977. With templates in C++, generic programming became part of the repertoire of professional library design. The techniques were further improved and parameterized types were introduced in the influential 1994 book Design Patterns.
New techniques were introduced by Andrei Alexandrescu in his 2001 book Modern C++ Design: Generic Programming and Design Patterns Applied. Subsequently, D implemented the same ideas.
Such software entities are known as generics in Ada, C#, Delphi, Eiffel, F#, Java, Nim, Python, Go, Rust, Swift, TypeScript, and Visual Basic (.NET). They are known as parametric polymorphism in ML, Scala, Julia, and Haskell. (Haskell terminology also uses the term generic for a related but somewhat different concept.)
The term generic programming was originally coined by David Musser and Alexander Stepanov in a more specific sense than the above, to describe a programming paradigm in which fundamental requirements on data types are abstracted from across concrete examples of algorithms and data structures and formalized as concepts, with generic functions implemented in terms of these concepts, typically using language genericity mechanisms as described above.
== Stepanov–Musser and other generic programming paradigms ==
Generic programming is defined in Musser & Stepanov (1989) as follows,
Generic programming centers around the idea of abstracting from concrete, efficient algorithms to obtain generic algorithms that can be combined with different data representations to produce a wide variety of useful software.
The "generic programming" paradigm is an approach to software decomposition whereby fundamental requirements on types are abstracted from across concrete examples of algorithms and data structures and formalized as concepts, analogously to the abstraction of algebraic theories in abstract algebra. Early examples of this programming approach were implemented in Scheme and Ada, although the best known example is the Standard Template Library (STL), which developed a theory of iterators that is used to decouple sequence data structures and the algorithms operating on them.
For example, given N sequence data structures, e.g. singly linked list, vector etc., and M algorithms to operate on them, e.g. find, sort etc., a direct approach would implement each algorithm specifically for each data structure, giving N × M combinations to implement. However, in the generic programming approach, each data structure returns a model of an iterator concept (a simple value type that can be dereferenced to retrieve the current value, or changed to point to another value in the sequence) and each algorithm is instead written generically with arguments of such iterators, e.g. a pair of iterators pointing to the beginning and end of the subsequence or range to process. Thus, only N + M data structure-algorithm combinations need be implemented. Several iterator concepts are specified in the STL, each a refinement of more restrictive concepts e.g. forward iterators only provide movement to the next value in a sequence (e.g. suitable for a singly linked list or a stream of input data), whereas a random-access iterator also provides direct constant-time access to any element of the sequence (e.g. suitable for a vector). An important point is that a data structure will return a model of the most general concept that can be implemented efficiently—computational complexity requirements are explicitly part of the concept definition. This limits the data
|
https://en.wikipedia.org/wiki/Generic_programming
|
Linear programming (LP), also called linear optimization, is a method to achieve the best outcome (such as maximum profit or lowest cost) in a mathematical model whose requirements and objective are represented by linear relationships. Linear programming is a special case of mathematical programming (also known as mathematical optimization).
More formally, linear programming is a technique for the optimization of a linear objective function, subject to linear equality and linear inequality constraints. Its feasible region is a convex polytope, which is a set defined as the intersection of finitely many half spaces, each of which is defined by a linear inequality. Its objective function is a real-valued affine (linear) function defined on this polytope. A linear programming algorithm finds a point in the polytope where this function has the largest (or smallest) value if such a point exists.
Linear programs are problems that can be expressed in standard form as:
Find a vector
x
that maximizes
c
T
x
subject to
A
x
≤
b
and
x
≥
0
.
{\displaystyle {\begin{aligned}&{\text{Find a vector}}&&\mathbf {x} \\&{\text{that maximizes}}&&\mathbf {c} ^{\mathsf {T}}\mathbf {x} \\&{\text{subject to}}&&A\mathbf {x} \leq \mathbf {b} \\&{\text{and}}&&\mathbf {x} \geq \mathbf {0} .\end{aligned}}}
Here the components of
x
{\displaystyle \mathbf {x} }
are the variables to be determined,
c
{\displaystyle \mathbf {c} }
and
b
{\displaystyle \mathbf {b} }
are given vectors, and
A
{\displaystyle A}
is a given matrix. The function whose value is to be maximized (
x
↦
c
T
x
{\displaystyle \mathbf {x} \mapsto \mathbf {c} ^{\mathsf {T}}\mathbf {x} }
in this case) is called the objective function. The constraints
A
x
≤
b
{\displaystyle A\mathbf {x} \leq \mathbf {b} }
and
x
≥
0
{\displaystyle \mathbf {x} \geq \mathbf {0} }
specify a convex polytope over which the objective function is to be optimized.
Linear programming can be applied to various fields of study. It is widely used in mathematics and, to a lesser extent, in bus
|
https://en.wikipedia.org/wiki/Linear_programming
|
Dynamic programming is both a mathematical optimization method and an algorithmic paradigm. The method was developed by Richard Bellman in the 1950s and has found applications in numerous fields, from aerospace engineering to economics.
In both contexts it refers to simplifying a complicated problem by breaking it down into simpler sub-problems in a recursive manner. While some decision problems cannot be taken apart this way, decisions that span several points in time do often break apart recursively. Likewise, in computer science, if a problem can be solved optimally by breaking it into sub-problems and then recursively finding the optimal solutions to the sub-problems, then it is said to have optimal substructure.
If sub-problems can be nested recursively inside larger problems, so that dynamic programming methods are applicable, then there is a relation between the value of the larger problem and the values of the sub-problems. In the optimization literature this relationship is called the Bellman equation.
== Overview ==
=== Mathematical optimization ===
In terms of mathematical optimization, dynamic programming usually refers to simplifying a decision by breaking it down into a sequence of decision steps over time.
This is done by defining a sequence of value functions V1, V2, ..., Vn taking y as an argument representing the state of the system at times i from 1 to n.
The definition of Vn(y) is the value obtained in state y at the last time n.
The values Vi at earlier times i = n −1, n − 2, ..., 2, 1 can be found by working backwards, using a recursive relationship called the Bellman equation.
For i = 2, ..., n, Vi−1 at any state y is calculated from Vi by maximizing a simple function (usually the sum) of the gain from a decision at time i − 1 and the function Vi at the new state of the system if this decision is made.
Since Vi has already been calculated for the needed states, the above operation yields Vi−1 for those states.
Finally, V1 at the initial state of the system is the value of the optimal solution. The optimal values of the decision variables can be recovered, one by one, by tracking back the calculations already performed.
=== Control theory ===
In control theory, a typical problem is to find an admissible control
u
∗
{\displaystyle \mathbf {u} ^{\ast }}
which causes the system
x
˙
(
t
)
=
g
(
x
(
t
)
,
u
(
t
)
,
t
)
{\displaystyle {\dot {\mathbf {x} }}(t)=\mathbf {g} \left(\mathbf {x} (t),\mathbf {u} (t),t\right)}
to follow an admissible trajectory
x
∗
{\displaystyle \mathbf {x} ^{\ast }}
on a continuous time interval
t
0
≤
t
≤
t
1
{\displaystyle t_{0}\leq t\leq t_{1}}
that minimizes a cost function
J
=
b
(
x
(
t
1
)
,
t
1
)
+
∫
|
https://en.wikipedia.org/wiki/Dynamic_programming
|
A programming game is a video game that incorporates elements of computer programming, enabling the player to direct otherwise autonomous units within the game to follow commands in a domain-specific programming language, often represented as a visual language to simplify the programming metaphor. Programming games broadly fall into two areas: single-player games where the programming elements either make up part of or the whole of a puzzle game, and multiplayer games where the player's automated program is pitted against other players' programs.
== As puzzle games ==
Early games in the genre include System 15000 and Hacker, released in 1984 and 1985 respectively.
Programming games have been used as part of puzzle games, challenging the player to achieve a specific result once the program starts operating. An example of such a game is SpaceChem, where the player must use its visual language to manipulate two waldos as to disassemble and reassemble chemical molecules. In such games, players are able to test and debug their program as often as necessary until they find a solution that works. Many of these games encourage the player to find the most efficient program, measured by the number of timesteps needed or number of commands required. Other similar games include Human Resource Machine, Infinifactory, and TIS-100. Zachtronics is a video game development company known for its programming-centric puzzle games.
Other games incorporate the elements of programming as portions of puzzles in the larger game. For example, Hack 'n' Slash include a metaphor of being able to access the internal programs and variables of objects represented in the game world, pausing the rest of the game as the player engages this programming interface, and modify the object's program as to progress further; this might be changing the state of an object from being indestructible to destructible. Other similar games with this type of programming approach include Transistor, else Heart.Break(), Glitchspace, and Pony Island.
Another approach used in some graphical games with programming elements is to present the player with a command line interface to issue orders via a domain-specific language to direct objects within the game, allowing the player to reissue commands as the situation changes rather than crafting a pre-made program. Games like Quadrilateral Cowboy and Duskers have the user command several small robotic creatures in tandem through the language of code to reach a certain goal. Hackmud presents the player with a simulated mainframe interface through which they issue commands to progress forward.
== As competitive games ==
Many programming games involve controlling entities such as robots, tanks or bacteria which seek to destroy each other. Such games can be considered environments of digital organisms, related to artificial life simulations. An early example is Core War (1984), where programs written in a standardized assembly-like language battle for space in a finite memory (virtual magnetic cores). Players are given tools to develop and test out their programs within the game's domain-specific language before submitting the program to a central server. The server then executes the program against others and reports the results to the player, from which they can make changes or improvements to the program.
There are different tournaments and leagues for the programming games where the characters can compete with each other. Usually a script is optimized for a special strategy. Similar approaches are used for more traditional games; the World Computer Chess Championship consists of matches between programs written for the abstract strategy game of chess.
The competitive programming game has also found its way to various board games such as RoboRally or Robot Turtles, typically where a program becomes a premade deck of playing cards played one by one to execute that code.
Researchers presented RoboCode as a "problem-based learning" subs
|
https://en.wikipedia.org/wiki/Programming_game
|
Procedural programming is a programming paradigm, classified as imperative programming, that involves implementing the behavior of a computer program as procedures (a.k.a. functions, subroutines) that call each other. The resulting program is a series of steps that forms a hierarchy of calls to its constituent procedures.
The first major procedural programming languages appeared c. 1957–1964, including Fortran, ALGOL, COBOL, PL/I and BASIC. Pascal and C were published c. 1970–1972.
Computer processors provide hardware support for procedural programming through a stack register and instructions for calling procedures and returning from them. Hardware support for other types of programming is possible, like Lisp machines or Java processors, but no attempt was commercially successful.
== Development practices ==
Certain software development practices are often employed with procedural programming in order to enhance quality and lower development and maintenance costs.
=== Modularity and scoping ===
Modularity is about organizing the procedures of a program into separate modules—each of which has a specific and understandable purpose.
Minimizing the scope of variables and procedures can enhance software quality by reducing the cognitive load of procedures and modules.
A program lacking modularity or wide scoping tends to have procedures that consume many variables that other procedures also consume. The resulting code is relatively hard to understand and to maintain.
=== Sharing ===
Since a procedure can specify a well-defined interface and be self-contained it supports code reuse—in particular via the software library.
== Comparison with other programming paradigms ==
=== Imperative programming ===
Procedural programming is classified as an imperative programming, because it involves direct command of execution.
Procedural is a sub-class of imperative since procedural includes block and scope concepts, whereas imperative describes a more general concept that does not require such features. Procedural languages generally use reserved words that define blocks, such as if, while, and for, to implement control flow, whereas non-structured imperative languages (i.e. assembly language) use goto and branch tables for this purpose.
=== Object-oriented programming ===
Also classified as imperative, object-oriented programming (OOP) involves dividing a program implementation into objects that expose behavior (methods) and data (members) via a well-defined interface. In contrast, procedural programming is about dividing the program implementation into variables, data structures, and subroutines. An important distinction is that while procedural involves procedures to operate on data structures, OOP bundles the two together. An object is a data structure and the behavior associated with that data structure.
Some OOP languages support the class concept which allows for creating an object based on a definition.
Nomenclature varies between the two, although they have similar semantics:
=== Functional programming ===
The principles of modularity and code reuse in functional languages are fundamentally the same as in procedural languages, since they both stem from structured programming. For example:
Procedures correspond to functions. Both allow the reuse of the same code in various parts of the programs, and at various points of its execution.
By the same token, procedure calls correspond to function application.
Functions and their modularly separated from each other in the same manner, by the use of function arguments, return values and variable scopes.
The main difference between the styles is that functional programming languages remove or at least deemphasize the imperative elements of procedural programming. The feature set of functional languages is therefore designed to support writing programs as much as possible in terms of pure functions:
Whereas procedural languages model execution of the program as a sequence of i
|
https://en.wikipedia.org/wiki/Procedural_programming
|
Goal programming is a branch of multiobjective optimization, which in turn is a branch of multi-criteria decision analysis (MCDA). It can be thought of as an extension or generalisation of linear programming to handle multiple, normally conflicting objective measures. Each of these measures is given a goal or target value to be achieved. Deviations are measured from these goals both above and below the target. Unwanted deviations from this set of target values are then minimised in an achievement function. This can be a vector or a weighted sum dependent on the goal programming variant used. As satisfaction of the target is deemed to satisfy the decision maker(s), an underlying satisficing philosophy is assumed. Goal programming is used to perform three types of analysis:
Determine the required resources to achieve a desired set of objectives.
Determine the degree of attainment of the goals with the available resources.
Providing the best satisfying solution under a varying amount of resources and priorities of the goals.
== History ==
Goal programming was first used by Charnes, Cooper and Ferguson in 1955, although the actual name first appeared in a 1961 text by Charnes and Cooper. Seminal works by Lee, Ignizio, Ignizio and Cavalier, and Romero followed. Schniederjans gives in a bibliography of a large number of pre-1995 articles relating to goal programming, and Jones and Tamiz give an annotated bibliography of the period 1990-2000. A recent textbook by Jones and Tamiz . gives a comprehensive overview of the state-of-the-art in goal programming.
The first engineering application of goal programming, due to Ignizio in 1962, was the design and placement of the antennas employed on the second stage of the Saturn V. This was used to launch the Apollo space capsule that landed the first men on the moon.
== Variants ==
The initial goal programming formulations ordered the unwanted deviations into a number of priority levels, with the minimisation of a deviation in a higher priority level being infinitely more important than any deviations in lower priority levels. This is known as lexicographic or pre-emptive goal programming. Ignizio gives an algorithm showing how a lexicographic goal programme can be solved as a series of linear programmes. Lexicographic goal programming is used when there exists a clear priority ordering amongst the goals to be achieved.
If the decision maker is more interested in direct comparisons of the objectives then weighted or non-pre-emptive goal programming should be used. In this case, all the unwanted deviations are multiplied by weights, reflecting their relative importance, and added together as a single sum to form the achievement function. Deviations measured in different units cannot be summed directly due to the phenomenon of incommensurability.
Hence each unwanted deviation is multiplied by a normalisation constant to allow direct comparison. Popular choices for normalisation constants are the goal target value of the corresponding objective (hence turning all deviations into percentages) or the range of the corresponding objective (between the best and the worst possible values, hence mapping all deviations onto a zero-one range). For decision makers more interested in obtaining a balance between the competing objectives, Chebyshev goal programming is used. Introduced by Flavell in 1976, this variant seeks to minimise the maximum unwanted deviation, rather than the sum of deviations. This utilises the Chebyshev distance metric.
== Strengths and weaknesses ==
A major strength of goal programming is its simplicity and ease of use. This accounts for the large number of goal programming applications in many and diverse fields. Linear goal programmes can be solved using linear programming software as either a single linear programme, or in the case of the lexicographic variant, a series of connected linear programmes.
Goal programming can hence handle relatively large numbers of variab
|
https://en.wikipedia.org/wiki/Goal_programming
|
In computer programming, initialization or initialisation is the assignment of an initial value for a data object or variable. The manner in which initialization is performed depends on the programming language, as well as the type, storage class, etc., of an object to be initialized. Programming constructs which perform initialization are typically called initializers and initializer lists. Initialization is distinct from (and preceded by) declaration, although the two can sometimes be conflated in practice. The complement of initialization is finalization, which is primarily used for objects, but not variables.
Initialization is done either by statically embedding the value at compile time, or else by assignment at run time. A section of code that performs such initialization is generally known as "initialization code" and may include other, one-time-only, functions such as opening files; in object-oriented programming, initialization code may be part of a constructor (class method) or an initializer (instance method). Setting a memory location to hexadecimal zeroes is also sometimes known as "clearing" and is often performed by an exclusive or instruction (both operands specifying the same variable), at machine code level, since it requires no additional memory access.
== C family of languages ==
=== Initializer ===
In C/C99/C++, an initializer is an optional part of a declarator. It consists of the '=' character followed by an expression or a comma-separated list of expressions placed in curly brackets (braces). The latter list is sometimes called the "initializer list" or "initialization list" (although the term "initializer list" is formally reserved for initialization of class/struct members in C++; see below).
A declaration which creates a data object, instead of merely describing its existence, is commonly called a definition.
Many find it convenient to draw a distinction between the terms "declaration" and "definition", as in the commonly seen phrase "the distinction between a declaration and definition...", implying that a declaration merely designates a data object (or function). In fact, according to the C++ standard, a definition is a declaration. Still, the usage "declarations and definitions", although formally incorrect, is common. Although all definitions are declarations, not all declarations are definitions.
C examples:
C++ examples:
=== Initializer list ===
In C++, a constructor of a class/struct can have an initializer list within the definition but prior to the constructor body. It is important to note that when you use an initialization list, the values are not assigned to the variable. They are initialized. In the below example, 0 is initialized into re and im.
Example:
Here, the construct : re(0), im(0) is the initializer list.
Sometimes the term "initializer list" is also used to refer to the list of expressions in the array or struct initializer.
C++11 provides for a more powerful concept of initializer lists, by means of a template, called std::initializer_list.
=== Default initialization ===
Data initialization may occur without explicit syntax in a program to do so. For example, if static variables are declared without an initializer, then those of primitive data types are initialized with the value of zero of the corresponding type, while static objects of class type are initialized with their default constructors.
== See also ==
Object lifetime
Finalizer Process & related Finalization Pattern
== References ==
|
https://en.wikipedia.org/wiki/Initialization_(programming)
|
Pair programming is a software development technique in which two programmers work together at one workstation. One, the driver, writes code while the other, the observer or navigator, reviews each line of code as it is typed in. The two programmers switch roles frequently.
While reviewing, the observer also considers the "strategic" direction of the work, coming up with ideas for improvements and likely future problems to address. This is intended to free the driver to focus all of their attention on the "tactical" aspects of completing the current task, using the observer as a safety net and guide.
== Economics ==
Pair programming increases the man-hours required to deliver code compared to programmers working individually. However, the resulting code has fewer defects. Along with code development time, other factors like field support costs and quality assurance also figure into the return on investment. Pair programming might theoretically offset these expenses by reducing defects in the programs.
In addition to preventing mistakes as they are made, other intangible benefits may exist. For example, the courtesy of rejecting phone calls or other distractions while working together, taking fewer breaks at agreed-upon intervals or sharing breaks to return phone calls (but returning to work quickly since someone is waiting). One member of the team might have more focus and help drive or awaken the other if they lose focus, and that role might periodically change. One member might know about a topic or technique that the other does not, which might eliminate delays to finding or testing a solution, or allow for a better solution, thus effectively expanding the skill set, knowledge, and experience of a programmer as compared to working alone. Each of these intangible benefits, and many more, may be challenging to accurately measure but can contribute to more efficient working hours.
== Design quality ==
A system with two programmers possesses greater potential for the generation of more diverse solutions to problems for three reasons:
the programmers bring different prior experiences to the task;
they may assess information relevant to the task in different ways;
they stand in different relationships to the problem by their functional roles.
In an attempt to share goals and plans, the programmers must overtly negotiate a shared course of action when a conflict arises between them. In doing so, they consider a larger number of ways of solving the problem than a single programmer alone might do. This significantly improves the design quality of the program as it reduces the chances of selecting a poor method.
== Satisfaction ==
In an online survey of pair programmers from 2000, 96% of programmers stated that they enjoyed working more while pair programming than programming alone. Furthermore, 95% said that they were more confident in their work when they pair programmed. However, as the survey was among self-selected pair programmers, it did not account for programmers who were forced to pair program.
== Learning ==
Knowledge is constantly shared between pair programmers, whether in the industry or in a classroom. Many sources suggest that students show higher confidence when programming in pairs, and many learn whether it be from tips on programming language rules to overall design skills. In "promiscuous pairing", each programmer communicates and works with all the other programmers on the team rather than pairing only with one partner, which causes knowledge of the system to spread throughout the whole team. Pair programming allows programmers to examine their partner's code and provide feedback, which is necessary to increase their own ability to develop monitoring mechanisms for their own learning activities.
== Team-building and communication ==
Pair programming allows team members to share quickly, making them less likely to have agendas hidden from each other. This helps pair programmers learn to communicat
|
https://en.wikipedia.org/wiki/Pair_programming
|
In computer science, a semaphore is a variable or abstract data type used to control access to a common resource by multiple threads and avoid critical section problems in a concurrent system such as a multitasking operating system. Semaphores are a type of synchronization primitive. A trivial semaphore is a plain variable that is changed (for example, incremented or decremented, or toggled) depending on programmer-defined conditions.
A useful way to think of a semaphore as used in a real-world system is as a record of how many units of a particular resource are available, coupled with operations to adjust that record safely (i.e., to avoid race conditions) as units are acquired or become free, and, if necessary, wait until a unit of the resource becomes available.
Though semaphores are useful for preventing race conditions, they do not guarantee their absence. Semaphores that allow an arbitrary resource count are called counting semaphores, while semaphores that are restricted to the values 0 and 1 (or locked/unlocked, unavailable/available) are called binary semaphores and are used to implement locks.
The semaphore concept was invented by Dutch computer scientist Edsger Dijkstra in 1962 or 1963, when Dijkstra and his team were developing an operating system for the Electrologica X8. That system eventually became known as the THE multiprogramming system.
== Library analogy ==
Suppose a physical library has ten identical study rooms, to be used by one student at a time. Students must request a room from the front desk. If no rooms are free, students wait at the desk until someone relinquishes a room. When a student has finished using a room, the student must return to the desk and indicate that the room is free.
In the simplest implementation, the clerk at the front desk knows only the number of free rooms available. This requires that all of the students use their room while they have signed up for it and return it when they are done. When a student requests a room, the clerk decreases this number. When a student releases a room, the clerk increases this number. The room can be used for as long as desired, and so it is not possible to book rooms ahead of time.
In this scenario, the front desk count-holder represents a counting semaphore, the rooms are the resource, and the students represent processes/threads. The value of the semaphore in this scenario is initially 10, with all rooms empty. When a student requests a room, they are granted access, and the value of the semaphore is changed to 9. After the next student comes, it drops to 8, then 7, and so on. If someone requests a room and the current value of the semaphore is 0, they are forced to wait until a room is freed (when the count is increased from 0). If one of the rooms was released, but there are several students waiting, then any method can be used to select the one who will occupy the room (like FIFO or randomly picking one). And of course, a student must inform the clerk about releasing their room only after really leaving it.
=== Important observations ===
When used to control access to a pool of resources, a semaphore tracks only how many resources are free. It does not keep track of which of the resources are free. Some other mechanism (possibly involving more semaphores) may be required to select a particular free resource.
The paradigm is especially powerful because the semaphore count may serve as a useful trigger for a number of different actions. The librarian above may turn the lights off in the study hall when there are no students remaining, or may place a sign that says the rooms are very busy when most of the rooms are occupied.
The success of the protocol requires applications to follow it correctly. Fairness and safety are likely to be compromised (which practically means a program may behave slowly, act erratically, hang, or crash) if even a single process acts incorrectly. This includes:
requesting a resource and forgetting to release it;
|
https://en.wikipedia.org/wiki/Semaphore_(programming)
|
In computer science, declarative programming is a programming paradigm—a style of building the structure and elements of computer programs—that expresses the logic of a computation without describing its control flow.
Many languages that apply this style attempt to minimize or eliminate side effects by describing what the program must accomplish in terms of the problem domain, rather than describing how to accomplish it as a sequence of the programming language primitives (the how being left up to the language's implementation). This is in contrast with imperative programming, which implements algorithms in explicit steps.
Declarative programming often considers programs as theories of a formal logic, and computations as deductions in that logic space. Declarative programming may greatly simplify writing parallel programs.
Common declarative languages include those of database query languages (e.g., SQL, XQuery), regular expressions, logic programming (e.g. Prolog, Datalog, answer set programming), functional programming, configuration management, and algebraic modeling systems.
== Definition ==
Declarative programming is often defined as any style of programming that is not imperative. A number of other common definitions attempt to define it by simply contrasting it with imperative programming. For example:
A high-level program that describes what a computation should perform.
Any programming language that lacks side effects (or more specifically, is referentially transparent).
A language with a clear correspondence to mathematical logic.
These definitions overlap substantially.
Declarative programming is a non-imperative style of programming in which programs describe their desired results without explicitly listing commands or steps that must be performed. Functional and logic programming languages are characterized by a declarative programming style. In logic programming, programs consist of sentences expressed in logical form, and computation uses those sentences to solve problems, which are also expressed in logical form.
In a pure functional language, such as Haskell, all functions are without side effects, and state changes are only represented as functions that transform the state, which is explicitly represented as a first-class object in the program. Although pure functional languages are non-imperative, they often provide a facility for describing the effect of a function as a series of steps. Other functional languages, such as Lisp, OCaml and Erlang, support a mixture of procedural and functional programming.
Some logic programming languages, such as Prolog, and database query languages, such as SQL, while declarative in principle, also support a procedural style of programming.
== Subparadigms ==
Declarative programming is an umbrella term that includes a number of better-known programming paradigms.
=== Constraint programming ===
Constraint programming states relations between variables in the form of constraints that specify the properties of the target solution. The set of constraints is solved by giving a value to each variable so that the solution is consistent with the maximum number of constraints. Constraint programming often complements other paradigms: functional, logical, or even imperative programming.
=== Domain-specific languages ===
Well-known examples of declarative domain-specific languages (DSLs) include the yacc parser generator input language, QML, the Make build specification language, Puppet's configuration management language, regular expressions, Datalog, answer set programming and a subset of SQL (SELECT queries, for example). DSLs have the advantage of being useful while not necessarily needing to be Turing-complete, which makes it easier for a language to be purely declarative.
Many markup languages such as HTML, MXML, XAML, XSLT or other user-interface markup languages are often declarative. HTML, for example, only describes what should appear on a webpage - it specifies
|
https://en.wikipedia.org/wiki/Declarative_programming
|
Modular programming is a software design technique that emphasizes separating the functionality of a program into independent, interchangeable modules, such that each contains everything necessary to execute only one aspect or "concern" of the desired functionality.
A module interface expresses the elements that are provided and required by the module. The elements defined in the interface are detectable by other modules. The implementation contains the working code that corresponds to the elements declared in the interface. Modular programming is closely related to structured programming and object-oriented programming, all having the same goal of facilitating construction of large software programs and systems by decomposition into smaller pieces, and all originating around the 1960s. While the historical usage of these terms has been inconsistent, "modular programming" now refers to the high-level decomposition of the code of an entire program into pieces: structured programming to the low-level code use of structured control flow, and object-oriented programming to the data use of objects, a kind of data structure.
In object-oriented programming, the use of interfaces as an architectural pattern to construct modules is known as interface-based programming.
== History ==
Modular programming, in the form of subsystems (particularly for I/O) and software libraries, dates to early software systems, where it was used for code reuse. Modular programming per se, with a goal of modularity, developed in the late 1960s and 1970s, as a larger-scale analog of the concept of structured programming (1960s). The term "modular programming" dates at least to the National Symposium on Modular Programming, organized at the Information and Systems Institute in July 1968 by Larry Constantine; other key concepts were information hiding (1972) and separation of concerns (SoC, 1974).
Modules were not included in the original specification for ALGOL 68 (1968), but were included as extensions in early implementations, ALGOL 68-R (1970) and ALGOL 68C (1970), and later formalized. One of the first languages designed from the start for modular programming was the short-lived Modula (1975), by Niklaus Wirth. Another early modular language was Mesa (1970s), by Xerox PARC, and Wirth drew on Mesa as well as the original Modula in its successor, Modula-2 (1978), which influenced later languages, particularly through its successor, Modula-3 (1980s). Modula's use of dot-qualified names, like M.a to refer to object a from module M, coincides with notation to access a field of a record (and similarly for attributes or methods of objects), and is now widespread, seen in C++, C#, Dart, Go, Java, OCaml, and Python, among others. Modular programming became widespread from the 1980s: the original Pascal language (1970) did not include modules, but later versions, notably UCSD Pascal (1978) and Turbo Pascal (1983) included them in the form of "units", as did the Pascal-influenced Ada (1980). The Extended Pascal ISO 10206:1990 standard kept closer to Modula2 in its modular support. Standard ML (1984) has one of the most complete module systems, including functors (parameterized modules) to map between modules.
In the 1980s and 1990s, modular programming was overshadowed by and often conflated with object-oriented programming, particularly due to the popularity of C++ and Java. For example, the C family of languages had support for objects and classes in C++ (originally C with Classes, 1980) and Objective-C (1983), only supporting modules 30 years or more later. Java (1995) supports modules in the form of packages, though the primary unit of code organization is a class. However, Python (1991) prominently used both modules and objects from the start, using modules as the primary unit of code organization and "packages" as a larger-scale unit; and Perl 5 (1994) includes support for both modules and objects, with a vast array of modules being available from CPAN (1993
|
https://en.wikipedia.org/wiki/Modular_programming
|
Programming is a form of music production and performance using electronic devices and computer software, such as sequencers and workstations or hardware synthesizers, sampler and sequencers, to generate sounds of musical instruments. These musical sounds are created through the use of music coding languages. There are many music coding languages of varying complexity. Music programming is also frequently used in modern pop and rock music from various regions of the world, and sometimes in jazz and contemporary classical music. It gained popularity in the 1950s and has been emerging ever since.
Music programming is the process in which a musician produces a sound or "patch" (be it from scratch or with the aid of a synthesizer/sampler), or uses a sequencer to arrange a song.
== Coding languages ==
Music coding languages are used to program the electronic devices to produce the instrumental sounds they make. Each coding language has its own level of difficulty and function.
=== Alda ===
The music coding language Alda provides a tutorial on coding music and is, "designed for musicians who do not know how to program, as well as programmers who do not know how to music". The website also has links to install, tutorial, cheat sheet, docs, and community for anyone visiting the website.
=== LC ===
LC computer music programming language is a more complex computer music programming language meant for more experienced coders. One of the differences between this language and other music coding languages is that, "Unlike existing unit-generator languages, LC provides objects as well as library functions and methods that can directly represent microsounds and related manipulations that are involved in microsound synthesis."
== History and development ==
Music programming has had a vast history of development leading to the creation of different programs and languages. Each development comes with more function and utility and each decade tends to favor a certain program and or piece of equipment.
=== MUSIC-N ===
The first digital synthesis family of computer programs and languages being MUSIC-N created by Max Mathews. The development of these programs, allowed for more flexibility and utility, eventually leading them to become fully developed languages. As programs such as MUSIC I, MUSIC II and MUSIC III were developed, which were all created by Max Matthews, new technologies were incorporated in such as the table-lookup oscillator in MUSIC II and the unit generator in MUSIC III. The breakthrough technologies such as the unit generator, which acted as a building block for music programming software, and the acoustic compiler, which allowed "unlimited number of sound synthesis structures to be created in the computer", further the complexity and evolution of music programming systems.
=== Drum machines ===
Around the time of the 1950s, electric rhythm machines began to make way into popular music. These machines began to gain much traction amongst many artists as they saw it as a way to create percussion sounds in an easier and more efficient way. Artists who used this kind of technology include J. J. Cale, Sly Stone, Phil Collins, Marvin Gaye, and Prince. Some of the popular drum machines through the time of the 1950s-1970s were the Side Man, Ace Tone's Rhythm Ace, Korg's Doncamatic, and Maestro's Rhythm King. In 1979, the LM-1 drum machine computer was released by guitarist Roger Linn, its goal being to help artists achieve realistic sounding drum sounds. This drum machine had eight different drum sounds: kick drum, snare, hi-hat, cabasa, tambourine, two tom toms, two congas, cowbell, clave, and handclaps. The different sounds could be recorded individually and they sounded real because of the high frequencies of the sound (28 kHz). Some notable artists who used the LM-1 were Peter Gabriel, Stevie Wonder, Michael Jackson, and Madonna. These developments continued to happen in future decades leading to the creation of new electr
|
https://en.wikipedia.org/wiki/Programming_(music)
|
An integer programming problem is a mathematical optimization or feasibility program in which some or all of the variables are restricted to be integers. In many settings the term refers to integer linear programming (ILP), in which the objective function and the constraints (other than the integer constraints) are linear.
Integer programming is NP-complete. In particular, the special case of 0–1 integer linear programming, in which unknowns are binary, and only the restrictions must be satisfied, is one of Karp's 21 NP-complete problems.
If some decision variables are not discrete, the problem is known as a mixed-integer programming problem.
== Canonical and standard form for ILPs ==
In integer linear programming, the canonical form is distinct from the standard form. An integer linear program in canonical form is expressed thus (note that it is the
x
{\displaystyle \mathbf {x} }
vector which is to be decided):
maximize
x
∈
Z
n
c
T
x
subject to
A
x
≤
b
,
x
≥
0
{\displaystyle {\begin{aligned}&{\underset {\mathbf {x} \in \mathbb {Z} ^{n}}{\text{maximize}}}&&\mathbf {c} ^{\mathrm {T} }\mathbf {x} \\&{\text{subject to}}&&A\mathbf {x} \leq \mathbf {b} ,\\&&&\mathbf {x} \geq \mathbf {0} \end{aligned}}}
and an ILP in standard form is expressed as
maximize
x
∈
Z
n
c
T
x
subject to
A
x
+
s
=
b
,
|
https://en.wikipedia.org/wiki/Integer_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.
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 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 '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 restart their own thought processes at any later time, and allows other programmers to understand the construction of the program more easily. This differs
|
https://en.wikipedia.org/wiki/Literate_programming
|
Fetal programming, also known as prenatal programming, is the theory that environmental cues experienced during fetal development play a seminal role in determining health trajectories across the lifespan.
Three main forms of programming that occur due to changes in the maternal environment are:
Changes in development that lead to greater disease risk;
Genetic changes that alter disease risk;
Epigenetic changes which alter disease risk of not only the child but also that of the next generation - i.e., after a famine, grandchildren of women who were pregnant during the famine, are born smaller than the normal size, despite nutritional deficiencies having been fulfilled.
These changes in the maternal environmental can be due to nutritional alteration, hormonal fluctuations or exposure to toxins.
== History ==
=== Dutch famine 1944–45 ===
In 1944–45, the German blockade of the Netherlands led to a lack of food supplies, causing the Dutch famine of 1944–45. The famine caused severe malnutrition among the population, including women in various stages of pregnancy. The Dutch Famine Birth Cohort Study examined the impact of lack of nutrition on children born during or after this famine. It showed that throughout their life, these children were at greater risk of diabetes, cardiovascular disease, obesity, and other non-communicable diseases.
=== Barker hypothesis ===
In the 1980s, David Barker began a research study on this topic. The Barker Hypothesis, or Thrifty phenotype, forms the basis for much of the research conducted on fetal programming. This hypothesis states that if the fetus is exposed to low nutrition, it will adapt to that environment. Nutrients are diverted towards the developing heart, brain, and other essential fetal organs. The body also undergoes metabolic alterations that ensure survival despite low nutrition but may cause problems with normal or high nutrition. This leads to increased risk of metabolic syndrome.
== Nutritional status ==
The developing fetus forms an impression of the world into which it will be born via its mother's nutritional status. Its development is thus modulated to create the best chance of survival. However, excessive or insufficient nutrition in the mother can provoke maladaptive developmental responses in the fetus, which in turn manifest in the form of post-natal diseases. This may have such a profound effect on the fetus’s adult life that it can even outweigh lifestyle factors.
=== Excessive nutrition ===
Body mass index before pregnancy and weight gain during pregnancy are linked to high blood pressure in the offspring during adulthood. Mouse models suggest that this is due to high levels of the fetal hormone leptin, which is present in the blood of individuals who are overweight or obese. There is a theory that this hormone hurts the regulatory systems of the fetus, and renders it impossible to maintain normal blood pressure levels.
=== Insufficient nutrition ===
Pre-eclampsia, involving oxygen deprivation and death of trophoblastic cells that make up most of the placenta, is a disease which is often associated with maladaptive long-term consequences of inappropriate fetal programming. Here, an inadequately developed and poorly functioning placenta fails to meet the fetus’s nutritional needs during gestation, either by altering its selection for nutrients that can cross into fetal blood or restricting total volume thereof. Consequences of this for the fetus in adult life include cardiovascular and metabolic conditions.
== Hormonal influence ==
A delicate balance of hormones during pregnancy is regarded as highly relevant to fetal programming and may significantly influence the outcome of the offspring. Placental endocrine transfer from the mother to the developing fetus could be altered by the mental state of the mother, due to affected glucocorticoid transfer that takes place across the placenta.
=== Thyroid ===
Thyroid hormones play an instrumental role during the
|
https://en.wikipedia.org/wiki/Fetal_programming
|
Logic programming is a programming, database and knowledge representation paradigm based on formal logic. A logic program is a set of sentences in logical form, representing knowledge about some problem domain. Computation is performed by applying logical reasoning to that knowledge, to solve problems in the domain. Major logic programming language families include Prolog, Answer Set Programming (ASP) and Datalog. In all of these languages, rules are written in the form of clauses:
A :- B1, ..., Bn.
and are read as declarative sentences in logical form:
A if B1 and ... and Bn.
A is called the head of the rule, B1, ..., Bn is called the body, and the Bi are called literals or conditions. When n = 0, the rule is called a fact and is written in the simplified form:
A.
Queries (or goals) have the same syntax as the bodies of rules and are commonly written in the form:
?- B1, ..., Bn.
In the simplest case of Horn clauses (or "definite" clauses), all of the A, B1, ..., Bn are atomic formulae of the form p(t1 ,..., tm), where p is a predicate symbol naming a relation, like "motherhood", and the ti are terms naming objects (or individuals). Terms include both constant symbols, like "charles", and variables, such as X, which start with an upper case letter.
Consider, for example, the following Horn clause program:
Given a query, the program produces answers.
For instance for a query ?- parent_child(X, william), the single answer is
Various queries can be asked. For instance
the program can be queried both to generate grandparents and to generate grandchildren. It can even be used to generate all pairs of grandchildren and grandparents, or simply to check if a given pair is such a pair:
Although Horn clause logic programs are Turing complete, for most practical applications, Horn clause programs need to be extended to "normal" logic programs with negative conditions. For example, the definition of sibling uses a negative condition, where the predicate = is defined by the clause X = X :
Logic programming languages that include negative conditions have the knowledge representation capabilities of a non-monotonic logic.
In ASP and Datalog, logic programs have only a declarative reading, and their execution is performed by means of a proof procedure or model generator whose behaviour is not meant to be controlled by the programmer. However, in the Prolog family of languages, logic programs also have a procedural interpretation as goal-reduction procedures. From this point of view, clause A :- B1,...,Bn is understood as:
to solve A, solve B1, and ... and solve Bn.
Negative conditions in the bodies of clauses also have a procedural interpretation, known as negation as failure: A negative literal not B is deemed to hold if and only if the positive literal B fails to hold.
Much of the research in the field of logic programming has been concerned with trying to develop a logical semantics for negation as failure and with developing other semantics and other implementations for negation. These developments have been important, in turn, for supporting the development of formal methods for logic-based program verification and program transformation.
== History ==
The use of mathematical logic to represent and execute computer programs is also a feature of the lambda calculus, developed by Alonzo Church in the 1930s. However, the first proposal to use the clausal form of logic for representing computer programs was made by Cordell Green. This used an axiomatization of a subset of LISP, together with a representation of an input-output relation, to compute the relation by simulating the execution of the program in LISP. Foster and Elcock's Absys, on the other hand, employed a combination of equations and lambda calculus in an assertional programming language that places no constraints on the order in which operations are performed.
Logic programming, with its current syntax of facts and rules, can be traced back to debates in the lat
|
https://en.wikipedia.org/wiki/Logic_programming
|
The terms local programme, local programming, local content or local television refers to a television program made by a television station or independent television producer for broadcast only within the station's transmission area or television market. Local programmes can encompass the whole range of programme genres but will usually only cover subjects or people of particular interest to an audience within the station's coverage area.
For example, a local sports programme will present results, interviews and coverage of games or matches, just like a network sports programme, but it would only feature teams and players from within the broadcaster's transmission area.
In some cases a television network programme may include a local element as well. This is particularly the case in the United Kingdom and still happens today with Politics Show. The BBC regions will all opt-out at the same time from the main programme to present a locally produced segment.
Sometimes locally made programmes that are not too specific to the transmission area, will be sold to other local stations for broadcast in their region.
Historically there was a large percentage of local programming on television. Late in the 20th century this has significantly fallen. In many cases the only local programmes on a television station today will be the local newscast.
The above can also apply to radio. A national radio network may have local studios or affiliates who opt-out at various times to present local programs and content.
In the late-1950s, many of the early Australian television series such as Melbourne Magazine (1957), Sydney Tonight (1956–1959), and TV Talent Scout (1957–1958) were broadcast in only a single city.
== Canada ==
In Canada, historically local television stations produced a significant volume of local programming, including newscasts, locally or regionally oriented talk shows, and variety entertainment programs such as Tiny Talent Time or Homegrown Cafe; a few stations, such as CHCH-TV in Hamilton, Ontario and CJOH in Ottawa, also distributed some of their local programming more widely through television syndication, most notably CHCH's Hilarious House of Frightenstein and CJOH's You Can't Do That on Television, both of which were broadcast across both Canada and the United States.
With the cross-national consolidation of Canadian media ownership in the 1990s and 2000s, network-affiliated stations now rarely produce much more than their own local or regional newscasts, although some stations may continue to produce a small amount of additional local programming. Independent stations may produce more local programming, although such stations are now rare in the Canadian media landscape.
In radio, virtually all Canadian commercial radio stations are officially programmed locally, although many stations cut costs by contracting some dayparts out to voice-tracked hosts who are not actually located in the station's physical studio or even necessarily in the same city, using a home studio, and may even be performing their show from the United States. The CBC Radio One, CBC Radio 2, Ici Radio-Canada Première and Ici Musique networks consist primarily of networked national programming, although all include some degree of local programming in certain time blocks. Radio One and Première stations have a significant number of production centres which create and air their own local morning and/or afternoon talk shows, while Radio 2's and Ici Musique's local content is limited to local news and weather updates.
== United States ==
The term is also generally accepted to refer to television programming that is not produced by a broadcast or other media source for national or international distribution (broadcast syndication). Usually programming of local interest is produced by either a Public, educational, and government access (PEG) television organization, cable TV operator or broadcast network affiliate stations that offer local radio news
|
https://en.wikipedia.org/wiki/Local_programming
|
Broadcast programming is the practice of organizing or ordering (scheduling) of broadcast media shows, typically radio and television, in a daily, weekly, monthly, quarterly, or season-long schedule.
Modern broadcasters use broadcast automation to regularly change the scheduling of their shows to build an audience for a new show, retain that audience, or compete with other broadcasters' shows. Most broadcast television shows are presented weekly in prime time or daily in other dayparts, though there are many exceptions.
At a micro level, scheduling is the minute planning of the transmission; what to broadcast and when, ensuring an adequate or maximum utilization of airtime. Television scheduling strategies are employed to give shows the best possible chance of attracting and retaining an audience. They are used to deliver shows to audiences when they are most likely to want to watch them and deliver audiences to advertisers in the composition that makes their advertising most likely to be effective.
With the growth of digital platforms and services allowing non-linear, on-demand access to television content, this approach to broadcasting has since been referred to using the retronym linear (such as linear television and linear channels).
== History ==
With the beginning of scheduled television in 1936, television programming was initially only concerned with filling a few hours each evening – the hours now known as prime time. Over time, though, television began to be seen during the daytime and late at night, as well on the weekends. As air time increased, so did the demand for new material. With the exception of sports television, variety shows became much more important in prime time.
== Scheduling strategies ==
=== Lead-ins and lead-outs ===
Broadcasters may schedule a program to air before or after a widely viewed tent-pole program, such as a popular series, or a special such as a high-profile sporting event (such as, in the United States, the Super Bowl), in the hope that audience flow will encourage the audience to tune-in early or stay for the second program. The second program is usually one that the broadcaster wants to promote to a wider audience, such as a new or lower-profile series. Sometimes, a lower-profile program may be scheduled between two tentpole programs, a technique known as hammocking.
Lead-outs can sometimes help to launch new programs and talent; in 1982, NBC premiered Late Night with David Letterman as a lead-out for its long-running late-night talk show The Tonight Show Starring Johnny Carson. Characterized by an off-beat style appealing to young adults, Late Night helped launch the career of host David Letterman, and influence later entries into the genre. Despite Carson's endorsement of Letterman as a successor following his 1992 retirement, NBC chose Jay Leno instead, and Letterman departed for CBS to host a spiritual successor—Late Show with David Letterman—beginning in the 1993–94 season. Late Night would continue as a franchise with hosts such as Conan O'Brien and Jimmy Fallon—both of whom would later go on to host The Tonight Show.
The same season, Fox scheduled The X-Files as a lead-out for its sci-fi western The Adventures of Brisco County Jr., with the expectation that Brisco County Jr. would serve as the anchor of its Friday-night lineup. However, The X-Files proved to be significantly more successful, and would eventually run for nine seasons. By contrast, viewership for Brisco County Jr. declined throughout the season, and the show was cancelled. Fox attempted to use other sci-fi shows as a lead-in for The X-Files (such as Sliders and VR.5), but they were similarly unsuccessful.
A weak lead-in can have an impact on the viewership of programs that follow; NBC's 2009 attempt to strip the talk show The Jay Leno Show (a spiritual successor to Leno's tenure of The Tonight Show after Conan O'Brien succeeded him) in a 10:00 p.m. ET/PT timeslot proved detrimental to the viewership of lat
|
https://en.wikipedia.org/wiki/Broadcast_programming
|
Object-oriented programming (OOP) is a programming paradigm based on the concept of objects. Objects can contain data (called fields, attributes or properties) and have actions they can perform (called procedures or methods and implemented in code). In OOP, computer programs are designed by making them out of objects that interact with one another.
Many of the most widely used programming languages (such as C++, Java, and Python) support object-oriented programming to a greater or lesser degree, typically as part of multiple paradigms in combination with others such as imperative programming and declarative programming.
Significant object-oriented languages include Ada, ActionScript, C++, Common Lisp, C#, Dart, Eiffel, Fortran 2003, Haxe, Java, JavaScript, Kotlin, Logo, MATLAB, Objective-C, Object Pascal, Perl, PHP, Python, R, Raku, Ruby, Scala, SIMSCRIPT, Simula, Smalltalk, Swift, Vala and Visual Basic.NET.
== History ==
The idea of "objects" in programming started with the artificial intelligence group at MIT in the late 1950s and early 1960s. Here, "object" referred to LISP atoms with identified properties (attributes).
Another early example was Sketchpad created by Ivan Sutherland at MIT in 1960–1961. In the glossary of his technical report, Sutherland defined terms like "object" and "instance" (with the class concept covered by "master" or "definition"), albeit specialized to graphical interaction. Later, in 1968, AED-0, MIT's version of the ALGOL programming language, connected data structures ("plexes") and procedures, prefiguring what were later termed "messages", "methods", and "member functions".
Topics such as data abstraction and modular programming were common points of discussion at this time.
Meanwhile, in Norway, Simula was developed during the years 1961–1967. Simula introduced essential object-oriented ideas, such as classes, inheritance, and dynamic binding.
Simula was used mainly by researchers involved with physical modelling, like the movement of ships and their content through cargo ports. Simula is generally accepted as being the first language with the primary features and framework of an object-oriented language.
Influenced by both MIT and Simula, Alan Kay began developing his own ideas in November 1966. He would go on to create Smalltalk, an influential object-oriented programming language. By 1967, Kay was already using the term "object-oriented programming" in conversation. Although sometimes called the "father" of object-oriented programming, Kay has said his ideas differ from how object-oriented programming is commonly understood, and has implied that the computer science establishment did not adopt his notion.
A 1976 MIT memo co-authored by Barbara Liskov lists Simula 67, CLU, and Alphard as object-oriented languages, but does not mention Smalltalk.
In the 1970s, the first version of the Smalltalk programming language was developed at Xerox PARC by Alan Kay, Dan Ingalls and Adele Goldberg. Smalltalk-72 was notable for use of objects at the language level and its graphical development environment. Smalltalk was a fully dynamic system, allowing users to create and modify classes as they worked. Much of the theory of OOP was developed in the context of Smalltalk, for example multiple inheritance.
In the late 1970s and 1980s, object-oriented programming rose to prominence. The Flavors object-oriented Lisp was developed starting 1979, introducing multiple inheritance and mixins. In August 1981, Byte Magazine highlighted Smalltalk and OOP, introducing these ideas to a wide audience. LOOPS, the object system for Interlisp-D, was influenced by Smalltalk and Flavors, and a paper about it was published in 1982. In 1986, the first Conference on Object-Oriented Programming, Systems, Languages, and Applications (OOPSLA) was attended by 1,000 people. This conference marked the beginning of efforts to consolidate Lisp object systems, eventually resulting in the Common Lisp Object System. In the 1980s, ther
|
https://en.wikipedia.org/wiki/Object-oriented_programming
|
In aspect and functional programming, advice describes a class of functions which modify other functions when the latter are run; it is a certain function, method or procedure that is to be applied at a given join point of a program.
== Use ==
The practical use of advice functions is generally to modify or otherwise extend the behavior of functions which cannot or should not be readily modified or extended. For instance, the Emacspeak Emacs-addon makes extensive use of advice: it must modify thousands of existing Emacs modules and functions such that it can produce audio output for the blind corresponding to the visual presentation, but it would be infeasible to copy all of them and redefine them to produce audio output in addition to their normal outputs; so, the Emacspeak programmers define advice functions which run before and after.
For a simple Emacs example: suppose after a user corrected a mis-spelled word using the Emacs ispell module, they wanted to re-spellcheck the entire buffer. ispell-word offers no such functionality, even if the corrected word appears frequently in the buffer. The user could track down the definition of ispell-word, copy it into their personal Emacs files, and add the desired functionality there, but this is tedious and, worse, brittle (the user's version is now out of sync with the core Emacs implementation, if it even works without further refactoring). What the user wants is quite simple — just to run another command any time ispell-word runs. Using advice, it can be done as simply as this:
While this example is obviously trivial, the strength of advice, especially when compared to similar facilities such as Python decorators and Java annotations, lies in the fact that not only do the advised functions / methods not need to be designed to accept advice, but also the advice themselves need not be designed to be usable as advice - they're just normal functions. The availability of evaluation throughout the lifetime of a piece of code (cf. code staging) in Lisp allows advice to be inlined automatically into any other code in a variety of ways. Any piece of code can be advised to carry out any other computation before, after, around, or instead of its original definition.
=== Readability ===
Advice has the potential to introduce confusion, as a piece of advice applied to a function is not apparent to a user who tracks down the function's source definition to learn about it. In such cases, advice acts almost like a COMEFROM, a joke facility added to INTERCAL to spoof the spaghettification attendant to the extensive use of GOTOs. In practice, however, such issues rarely present themselves. Upstream developers and maintainers of Lisp packages and modules never use advice, since there is no advantage to be gained by advising functions when their original source definitions can be freely rewritten to include the desired features. Advice is only useful in that it enables downstream users to subsequently modify default behaviour in a way that does not require propagation of such modifications into the core implementation's source definition.
== Implementations ==
A form of advices were part of C with Classes in the late 1970s and early 1980s, namely functions called call and return defined in a class, which were called before (respectively, after) member functions of the class. However, these were dropped from C++.
Advices are part of the Common Lisp Object System (CLOS), as :before, :after, and :around methods, which are combined with the primary method under "standard method combination".
Common Lisp implementations provide advice functionality (in addition to the standard method combination for CLOS) as extensions. LispWorks supports advising functions, macros and CLOS methods.
EmacsLisp added advice-related code in version 19.28, 1994.
== History ==
The following is taken from a discussion at the mailing list aosd-discuss. Pascal Costanza contributed the following:
The term "advice" goes b
|
https://en.wikipedia.org/wiki/Advice_(programming)
|
In computing, reactive programming is a declarative programming paradigm concerned with data streams and the propagation of change. With this paradigm, it is possible to express static (e.g., arrays) or dynamic (e.g., event emitters) data streams with ease, and also communicate that an inferred dependency within the associated execution model exists, which facilitates the automatic propagation of the changed data flow.
For example, in an imperative programming setting, a := b + c would mean that a is being assigned the result of b + c at the instant the expression is evaluated, and later, the values of b and c can be changed with no effect on the value of a. On the other hand, in reactive programming, the value of a is automatically updated whenever the values of b or c change, without the program having to explicitly re-state the statement a := b + c to re-assign the value of a.
Another example is a hardware description language such as Verilog, where reactive programming enables changes to be modeled as they propagate through circuits.
Reactive programming has been proposed as a way to simplify the creation of interactive user interfaces and near-real-time system animation.
For example, in a model–view–controller (MVC) architecture, reactive programming can facilitate changes in an underlying model being reflected automatically in an associated view.
== Approaches to creating reactive programming languages ==
Several popular approaches are employed in the creation of reactive programming languages. One approach is the specification of dedicated languages that are specific to various domain constraints. Such constraints usually are characterized by real-time, embedded computing or hardware description. Another approach involves the specification of general-purpose languages that include support for reactivity. Other approaches are articulated in the definition, and use of programming libraries, or embedded domain-specific languages, that enable reactivity alongside or on top of the programming language. Specification and use of these different approaches results in language capability trade-offs. In general, the more restricted a language is, the more its associated compilers and analysis tools are able to inform developers (e.g., in performing analysis for whether programs are able to execute in actual real-time). Functional trade-offs in specificity may result in deterioration of the general applicability of a language.
== Programming models and semantics ==
A variety of models and semantics govern reactive programming. We can loosely split them along the following dimensions:
Synchrony: synchronous versus asynchronous model of time
Determinism: deterministic versus non-deterministic evaluation process and results
Update process: callback versus dataflow versus actor
== Implementation techniques and challenges ==
=== Essence of implementations ===
Reactive programming language runtimes are represented by a graph that identifies the dependencies among the involved reactive values. In such a graph, nodes represent the act of computing, and edges model dependency relationships. Such a runtime employs said graph, to help it keep track of the various computations, which must be executed anew, once an involved input changes value.
==== Change propagation algorithms ====
The most common approaches to data propagation are:
Pull: The value consumer is in fact proactive, in that it regularly queries the observed source for values and reacts whenever a relevant value is available. This practice of regularly checking for events or value changes is commonly referred to as polling.
Push: The value consumer receives a value from the source whenever the value becomes available. These values are self-contained, e.g. they contain all the necessary information, and no further information needs to be queried by the consumer.
Push-pull: The value consumer receives a change notification, which is a short description of the change, e
|
https://en.wikipedia.org/wiki/Reactive_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 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-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. 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 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 associa
|
https://en.wikipedia.org/wiki/Symbol_(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 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 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 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 language's runtime. On machines with a single processor core where an implementation designed for parallel operation would simply introduce overhead, this
|
https://en.wikipedia.org/wiki/Dataflow_programming
|
A computer program is a sequence or set of instructions in a programming language for a computer to execute. It is one component of software, which also includes documentation and other intangible components.
A computer program in its human-readable form is called source code. Source code needs another computer program to execute because computers can only execute their native machine instructions. Therefore, source code may be translated to machine instructions using a compiler written for the language. (Assembly language programs are translated using an assembler.) The resulting file is called an executable. Alternatively, source code may execute within an interpreter written for the language.
If the executable is requested for execution, then the operating system loads it into memory and starts a process. The central processing unit will soon switch to this process so it can fetch, decode, and then execute each machine instruction.
If the source code is requested for execution, then the operating system loads the corresponding interpreter into memory and starts a process. The interpreter then loads the source code into memory to translate and execute each statement. Running the source code is slower than running an executable. Moreover, the interpreter must be installed on the computer.
== Example computer program ==
The "Hello, World!" program is used to illustrate a language's basic syntax. The syntax of the language BASIC (1964) was intentionally limited to make the language easy to learn. For example, variables are not declared before being used. Also, variables are automatically initialized to zero. Here is an example computer program, in Basic, to average a list of numbers:
Once the mechanics of basic computer programming are learned, more sophisticated and powerful languages are available to build large computer systems.
== History ==
Improvements in software development are the result of improvements in computer hardware. At each stage in hardware's history, the task of computer programming changed dramatically.
=== Analytical Engine ===
In 1837, Jacquard's loom inspired Charles Babbage to attempt to build the Analytical Engine.
The names of the components of the calculating device were borrowed from the textile industry. In the textile industry, yarn was brought from the store to be milled. The device had a store which consisted of memory to hold 1,000 numbers of 50 decimal digits each. Numbers from the store were transferred to the mill for processing. The engine was programmed using two sets of perforated cards. One set directed the operation and the other set inputted the variables. However, the thousands of cogged wheels and gears never fully worked together.
Ada Lovelace worked for Charles Babbage to create a description of the Analytical Engine (1843). The description contained Note G which completely detailed a method for calculating Bernoulli numbers using the Analytical Engine. This note is recognized by some historians as the world's first computer program.
=== Universal Turing machine ===
In 1936, Alan Turing introduced the Universal Turing machine, a theoretical device that can model every computation.
It is a finite-state machine that has an infinitely long read/write tape. The machine can move the tape back and forth, changing its contents as it performs an algorithm. The machine starts in the initial state, goes through a sequence of steps, and halts when it encounters the halt state. All present-day computers are Turing complete.
=== ENIAC ===
The Electronic Numerical Integrator And Computer (ENIAC) was built between July 1943 and Fall 1945. It was a Turing complete, general-purpose computer that used 17,468 vacuum tubes to create the circuits. At its core, it was a series of Pascalines wired together. Its 40 units weighed 30 tons, occupied 1,800 square feet (167 m2), and consumed $650 per hour (in 1940s currency) in electricity when idle. It had 20 base-10 accumulators. Programming t
|
https://en.wikipedia.org/wiki/Computer_program
|
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 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, 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, 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_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
|
https://en.wikipedia.org/wiki/Directive_(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 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 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 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 languages, such as Lisp, ML, and Haskell, tend to substitute a factorial program for "Hello, World!", as functional programming emphasizes recursive tec
|
https://en.wikipedia.org/wiki/%22Hello,_World!%22_program
|
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 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 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 ==
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
|
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.
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 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 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 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, 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 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
|
https://en.wikipedia.org/wiki/Neuro-linguistic_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 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 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 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 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
|
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
|
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 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 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 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 logic programming is a programming paradigm that extends logic programming with probabilities.
Most approaches to probabilistic logic programming ar
|
https://en.wikipedia.org/wiki/Probabilistic_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 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 – 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 or manipulate other programs (or themselves) as their data, or that do part of the work at compile time that would otherwise be done at runtime
Template metaprogramming – metaprogramming methods in which a compiler uses templates to generate temporary source code, which is merged by the compiler with the rest of the source code and then compiled
Reflective programming – metaprogramming methods in which a program modifies or extends itself
Pipeline programming – a simple syntax change to add syntax to nest function calls to language originally designed with none
Rule-based programming – a network of rules of thumb that comprise a knowledge base and can be used for expert systems and problem deduction & resolution
Visual programming – manipulating program elements graphically rather than by specifying them textually (e.g. Simulink); also termed diagrammatic programming'
Online presence management is distinct from
Web presence management in that the former is generally a marketing and messaging discipline while the latter is Governance,risk management, and compliance operational and s
|
https://en.wikipedia.org/wiki/Programming_paradigm
|
A programming tool or software development tool is a computer program that is used to develop another computer program, usually by helping the developer manage computer files. For example, a programmer may use a tool called a source code editor to edit source code files, and then a compiler to convert the source code into machine code files. They may also use build tools that automatically package executable program and data files into shareable packages or install kits.
A set of tools that are run one after another, with each tool feeding its output to the next one, is called a toolchain. An integrated development environment (IDE) integrates the function of several tools into a single program. Usually, an IDE provides a source code editor as well as other built-in or plug-in tools that help with compiling, debugging, and testing.
Whether a program is considered a development tool can be subjective. Some programs, such as the GNU compiler collection, are used exclusively for software development while others, such as Notepad, are not meant specifically for development but are nevertheless often used for programming.
== Categories ==
Notable categories of development tools:
Assembler – Converts assembly language into machine code
Bug tracking system – Software application that records software bugs
Build automation – Building software via an unattended fashion
Code review software – Activity where one or more people check a program's code
Compiler – Computer program which translates code from one programming language to another
Compiler-compiler – Program that generates parsers or compilers, a.k.a. parser generator
Debugger – Computer program used to test and debug other programs
Decompiler – Program translating executable to source code
Disassembler – Computer program to translate machine language into assembly language
Documentation generator – Automation technology for creating software documentation
Graphical user interface builder – Software development tool
Linker – Program that combines intermediate build files into an executable file
Memory debugger – Software memory problem finder
Minifier – Removal of unnecessary characters in code without changing its functionality
Pretty-printer – Formatting to make code or markup easier to readPages displaying short descriptions of redirect targets
Performance profiler – Measuring the time or resources used by a section of a computer program
Static code analyzer – Analysis of computer programs without executing themPages displaying short descriptions of redirect targets
Source code editor – Text editor specializing in software codePages displaying short descriptions of redirect targets
Source code generation – Type of computer programmingPages displaying short descriptions of redirect targets
Version control system – Stores and tracks versions of files
== See also ==
Call graph – Structure in computing
Comparison of integrated development environments – Notable software packages that are nominal IDE
Computer aided software engineering – Domain of software toolsPages displaying short descriptions of redirect targets
Git – Distributed version control software system
GitHub – Software development collaboration platform
Lint – Tool to flag poor computer code
List of software engineering topics – Overview of and topical guide to software engineeringPages displaying short descriptions of redirect targets
List of unit testing frameworks
Manual memory management – Computer memory management methodology
Memory leak – When a computer program fails to release unnecessary memory
Reverse-engineering – Process of extracting design information from anything artificialPages displaying short descriptions of redirect targets
Revision Control System – Version-control system
Software development kit – Set of software development tools
Software engineering – Engineering approach to software development
SourceForge – Software discovery and hosting platform for B2B and open source software
SWIG – O
|
https://en.wikipedia.org/wiki/Programming_tool
|
Go is a high-level general purpose programming language that is statically typed and compiled. It is known for the simplicity of its syntax and the efficiency of development that it enables by the inclusion of a large standard library supplying many needs for common projects. It was designed at Google in 2007 by Robert Griesemer, Rob Pike, and Ken Thompson, and publicly announced in November of 2009. It is syntactically similar to C, but also has memory safety, garbage collection, structural typing, and CSP-style concurrency. It is often referred to as Golang to avoid ambiguity and because of its former domain name, golang.org, but its proper name is Go.
There are two major implementations:
The original, self-hosting compiler toolchain, initially developed inside Google;
A frontend written in C++, called gofrontend, originally a GCC frontend, providing gccgo, a GCC-based Go compiler; later extended to also support LLVM, providing an LLVM-based Go compiler called gollvm.
A third-party source-to-source compiler, GopherJS, transpiles Go to JavaScript for front-end web development.
== History ==
Go was designed at Google in 2007 to improve programming productivity in an era of multicore, networked machines and large codebases. The designers wanted to address criticisms of other languages in use at Google, but keep their useful characteristics:
Static typing and run-time efficiency (like C)
Readability and usability (like Python)
High-performance networking and multiprocessing
Its designers were primarily motivated by their shared dislike of C++.
Go was publicly announced in November 2009, and version 1.0 was released in March 2012. Go is widely used in production at Google and in many other organizations and open-source projects.
In retrospect the Go authors judged Go to be successful due to the overall engineering work around the language, including the runtime support for the language's concurrency feature.
Although the design of most languages concentrates on innovations in syntax, semantics, or typing, Go is focused on the software development process itself. ... The principal unusual property of the language itself—concurrency—addressed problems that arose with the proliferation of multicore CPUs in the 2010s. But more significant was the early work that established fundamentals for packaging, dependencies, build, test, deployment, and other workaday tasks of the software development world, aspects
that are not usually foremost in language design.
=== Branding and styling ===
The Gopher mascot was introduced in 2009 for the open source launch of the language. The design, by Renée French, borrowed from a c. 2000 WFMU promotion.
In November 2016, the Go and Go Mono fonts were released by type designers Charles Bigelow and Kris Holmes specifically for use by the Go project. Go is a humanist sans-serif resembling Lucida Grande, and Go Mono is monospaced. Both fonts adhere to the WGL4 character set and were designed to be legible with a large x-height and distinct letterforms. Both Go and Go Mono adhere to the DIN 1450 standard by having a slashed zero, lowercase l with a tail, and an uppercase I with serifs.
In April 2018, the original logo was redesigned by brand designer Adam Smith. The new logo is a modern, stylized GO slanting right with trailing streamlines. (The Gopher mascot remained the same.)
=== Generics ===
The lack of support for generic programming in initial versions of Go drew considerable criticism. The designers expressed an openness to generic programming and noted that built-in functions were in fact type-generic, but are treated as special cases; Pike called this a weakness that might be changed at some point. The Google team built at least one compiler for an experimental Go dialect with generics, but did not release it.
In August 2018, the Go principal contributors published draft designs for generic programming and error handling and asked users to submit feedback. However, the error handling pro
|
https://en.wikipedia.org/wiki/Go_(programming_language)
|
Quadratic programming (QP) is the process of solving certain mathematical optimization problems involving quadratic functions. Specifically, one seeks to optimize (minimize or maximize) a multivariate quadratic function subject to linear constraints on the variables. Quadratic programming is a type of nonlinear programming.
"Programming" in this context refers to a formal procedure for solving mathematical problems. This usage dates to the 1940s and is not specifically tied to the more recent notion of "computer programming." To avoid confusion, some practitioners prefer the term "optimization" — e.g., "quadratic optimization."
== Problem formulation ==
The quadratic programming problem with n variables and m constraints can be formulated as follows.
Given:
a real-valued, n-dimensional vector c,
an n×n-dimensional real symmetric matrix Q,
an m×n-dimensional real matrix A, and
an m-dimensional real vector b,
the objective of quadratic programming is to find an n-dimensional vector x, that will
where xT denotes the vector transpose of x, and the notation Ax ⪯ b means that every entry of the vector Ax is less than or equal to the corresponding entry of the vector b (component-wise inequality).
=== Constrained least squares ===
As a special case when Q is symmetric positive-definite, the cost function reduces to least squares:
where Q = RTR follows from the Cholesky decomposition of Q and c = −RT d. Conversely, any such constrained least squares program can be equivalently framed as a quadratic programming problem, even for a generic non-square R matrix.
=== Generalizations ===
When minimizing a function f in the neighborhood of some reference point x0, Q is set to its Hessian matrix H(f(x0)) and c is set to its gradient ∇f(x0). A related programming problem, quadratically constrained quadratic programming, can be posed by adding quadratic constraints on the variables.
== Solution methods ==
For general problems a variety of methods are commonly used, including
interior point,
active set,
augmented Lagrangian,
conjugate gradient,
gradient projection,
extensions of the simplex algorithm.
In the case in which Q is positive definite, the problem is a special case of the more general field of convex optimization.
=== Equality constraints ===
Quadratic programming is particularly simple when Q is positive definite and there are only equality constraints; specifically, the solution process is linear. By using Lagrange multipliers and seeking the extremum of the Lagrangian, it may be readily shown that the solution to the equality constrained problem
Minimize
1
2
x
T
Q
x
+
c
T
x
{\displaystyle {\text{Minimize}}\quad {\tfrac {1}{2}}\mathbf {x} ^{\mathrm {T} }Q\mathbf {x} +\mathbf {c} ^{\mathrm {T} }\mathbf {x} }
subject to
E
x
=
d
{\displaystyle {\text{subject to}}\quad E\mathbf {x} =\mathbf {d} }
is given by the linear system
[
Q
E
⊤
E
0
]
|
https://en.wikipedia.org/wiki/Quadratic_programming
|
Constraint programming (CP) is a paradigm for solving combinatorial problems that draws on a wide range of techniques from artificial intelligence, computer science, and operations research. In constraint programming, users declaratively state the constraints on the feasible solutions for a set of decision variables. Constraints differ from the common primitives of imperative programming languages in that they do not specify a step or sequence of steps to execute, but rather the properties of a solution to be found. In addition to constraints, users also need to specify a method to solve these constraints. This typically draws upon standard methods like chronological backtracking and constraint propagation, but may use customized code like a problem-specific branching heuristic.
Constraint programming takes its root from and can be expressed in the form of constraint logic programming, which embeds constraints into a logic program. This variant of logic programming is due to Jaffar and Lassez, who extended in 1987 a specific class of constraints that were introduced in Prolog II. The first implementations of constraint logic programming were Prolog III, CLP(R), and CHIP.
Instead of logic programming, constraints can be mixed with functional programming, term rewriting, and imperative languages.
Programming languages with built-in support for constraints include Oz (functional programming) and Kaleidoscope (imperative programming). Mostly, constraints are implemented in imperative languages via constraint solving toolkits, which are separate libraries for an existing imperative language.
== Constraint logic programming ==
Constraint programming is an embedding of constraints in a host language. The first host languages used were logic programming languages, so the field was initially called constraint logic programming. The two paradigms share many important features, like logical variables and backtracking. Today most Prolog implementations include one or more libraries for constraint logic programming.
The difference between the two is largely in their styles and approaches to modeling the world. Some problems are more natural (and thus, simpler) to write as logic programs, while some are more natural to write as constraint programs.
The constraint programming approach is to search for a state of the world in which a large number of constraints are satisfied at the same time. A problem is typically stated as a state of the world containing a number of unknown variables. The constraint program searches for values for all the variables.
Temporal concurrent constraint programming (TCC) and non-deterministic temporal concurrent constraint programming (MJV) are variants of constraint programming that can deal with time.
== Constraint satisfaction problem ==
A constraint is a relation between multiple variables that limits the values these variables can take simultaneously.
Three categories of constraints exist:
extensional constraints: constraints are defined by enumerating the set of values that would satisfy them;
arithmetic constraints: constraints are defined by an arithmetic expression, i.e., using
<
,
>
,
≤
,
≥
,
=
,
≠
,
.
.
.
{\displaystyle <,>,\leq ,\geq ,=,\neq ,...}
;
logical constraints: constraints are defined with an explicit semantics, i.e., AllDifferent, AtMost,...
Assignment is the association of a variable to a value from its domain. A partial assignment is when a subset of the variables of the problem has been assigned. A total assignment is when all the variables of the problem have been assigned.
During the search of the solutions of a CSP, a user can wish for:
finding a solution (satisfying all the constraints);
finding all the solutions of the problem;
proving the unsatisfiability of the problem.
== Constraint optimization problem ==
A constra
|
https://en.wikipedia.org/wiki/Constraint_programming
|
Software consists of computer programs that instruct the execution of a computer. Software also includes design documents and specifications.
The history of software is closely tied to the development of digital computers in the mid-20th century. Early programs were written in the machine language specific to the hardware. The introduction of high-level programming languages in 1958 allowed for more human-readable instructions, making software development easier and more portable across different computer architectures. Software in a programming language is run through a compiler or interpreter to execute on the architecture's hardware. Over time, software has become complex, owing to developments in networking, operating systems, and databases.
Software can generally be categorized into two main types:
operating systems, which manage hardware resources and provide services for applications
application software, which performs specific tasks for users
The rise of cloud computing has introduced the new software delivery model Software as a Service (SaaS). In SaaS, applications are hosted by a provider and accessed over the Internet.
The process of developing software involves several stages. The stages include software design, programming, testing, release, and maintenance. Software quality assurance and security are critical aspects of software development, as bugs and security vulnerabilities can lead to system failures and security breaches. Additionally, legal issues such as software licenses and intellectual property rights play a significant role in the distribution of software products.
== History ==
The first use of the word software to describe computer programs is credited to mathematician John Wilder Tukey in 1958.
The first programmable computers, which appeared at the end of the 1940s, were programmed in machine language. Machine language is difficult to debug and not portable across different computers. Initially, hardware resources were more expensive than human resources. As programs became complex, programmer productivity became the bottleneck. The introduction of high-level programming languages in 1958 hid the details of the hardware and expressed the underlying algorithms into the code . Early languages include Fortran, Lisp, and COBOL.
== Types ==
There are two main types of software:
Operating systems are "the layer of software that manages a computer's resources for its users and their applications". There are three main purposes that an operating system fulfills:
Allocating resources between different applications, deciding when they will receive central processing unit (CPU) time or space in memory.
Providing an interface that abstracts the details of accessing hardware details (like physical memory) to make things easier for programmers.
Offering common services, such as an interface for accessing network and disk devices. This enables an application to be run on different hardware without needing to be rewritten.
Application software runs on top of the operating system and uses the computer's resources to perform a task. There are many different types of application software because the range of tasks that can be performed with modern computers is so large. Applications account for most software and require the environment provided by an operating system, and often other applications, in order to function.
Software can also be categorized by how it is deployed. Traditional applications are purchased with a perpetual license for a specific version of the software, downloaded, and run on hardware belonging to the purchaser. The rise of the Internet and cloud computing enabled a new model, software as a service (SaaS), in which the provider hosts the software (usually built on top of rented infrastructure or platforms) and provides the use of the software to customers, often in exchange for a subscription fee. By 2023, SaaS products—which are usually delivered via a web application—had become t
|
https://en.wikipedia.org/wiki/Software
|
Comet is a web application model in which a long-held HTTPS request allows a web server to push data to a browser, without the browser explicitly requesting it. Comet is an umbrella term, encompassing multiple techniques for achieving this interaction. All these methods rely on features included by default in browsers, such as JavaScript, rather than on non-default plugins. The Comet approach differs from the original model of the web, in which a browser requests a complete web page at a time.
The use of Comet techniques in web development predates the use of the word Comet as a neologism for the collective techniques. Comet is known by several other names, including
Ajax Push,
Reverse Ajax, Two-way-web, HTTP Streaming, and
HTTP server push
among others. The term Comet is not an acronym, but was coined by Alex Russell in his 2006 blog post.
In recent years, the standardisation and widespread support of WebSocket and Server-sent events has rendered the Comet model obsolete.
== History ==
=== Early Java applets ===
The ability to embed Java applets into browsers (starting with Netscape Navigator 2.0 in March 1996) made two-way sustained communications possible, using a raw TCP socket to communicate between the browser and the server. This socket can remain open as long as the browser is at the document hosting the applet. Event notifications can be sent in any format – text or binary – and decoded by the applet.
=== The first browser-to-browser communication framework ===
The very first application using browser-to-browser communications was Tango Interactive, implemented in 1996–98 at the Northeast Parallel Architectures Center (NPAC) at Syracuse University using DARPA funding. TANGO architecture has been patented by Syracuse University. TANGO framework has been extensively used as a distance education tool. The framework has been commercialized by CollabWorx and used in a dozen or so Command&Control and Training applications in the United States Department of Defense.
=== First Comet applications ===
The first set of Comet implementations dates back to 2000, with the Pushlets, Lightstreamer, and KnowNow projects. Pushlets, a framework created by Just van den Broecke, was one of the first open source implementations. Pushlets were based on server-side Java servlets, and a client-side JavaScript library. Bang Networks – a Silicon Valley start-up backed by Netscape co-founder Marc Andreessen – had a lavishly-financed attempt to create a real-time push standard for the entire web.
In April 2001, Chip Morningstar began developing a Java-based (J2SE) web server which used two HTTP sockets to keep open two communications channels between the custom HTTP server he designed and a client designed by Douglas Crockford; a functioning demo system existed as of June 2001. The server and client used a messaging format that the founders of State Software, Inc. assented to coin as JSON following Crockford's suggestion. The entire system, the client libraries, the messaging format known as JSON and the server, became the State Application Framework, parts of which were sold and used by Sun Microsystems, Amazon.com, EDS and Volkswagen.
In March 2006, software engineer Alex Russell coined the term Comet in a post on his personal blog. The new term was a play on Ajax (Ajax and Comet both being common household cleaners in the USA).
In 2006, some applications exposed those techniques to a wider audience: Meebo’s multi-protocol web-based chat application enabled users to connect to AOL, Yahoo, and Microsoft chat platforms through the browser; Google added web-based chat to Gmail; JotSpot, a startup since acquired by Google, built Comet-based real-time collaborative document editing. New Comet variants were created, such as the Java-based ICEfaces JSF framework (although they prefer the term "Ajax Push"). Others that had previously used Java-applet based transports switched instead to pure-JavaScript implementations.
== Implementations
|
https://en.wikipedia.org/wiki/Comet_(programming)
|
Egoless programming is a style of computer programming in which personal factors are minimized so that quality may be improved. The cooperative methods suggested are similar to those used by other collective ventures such as Wikipedia.
== History ==
The concept was first propounded by Gerald M. Weinberg in his 1971 book, The Psychology of Computer Programming.
== Peer reviews of code ==
To ensure quality, reviews of code by other programmers are made. The concept of egoless programming emphasises that such reviews should be made in a friendly, collegial way in which personal feelings are put aside. Structured walkthroughs are one way of making such a formal review.
== Strengths ==
Works best for complex tasks. ('difficult' used in )
Open communication channels allow information to flow freely to team members
Greater conformity that helps in consistent documentation
Team members have greater job satisfaction.
== Weaknesses ==
Projects take longer to complete.
Projects experience a higher failure rate due to the decentralized nature of and volume of communication between members of the team.
Risky shift phenomenon – Programmers attempt riskier solutions to solve a software problem.
Simple tasks are made more difficult by open communication channels.
Note: The single paper cited for 'Strengths & Weaknesses' is from 1981 and says in its conclusions:
Most of the research on group problem-solving behavior was conducted in a laboratory setting with students and tasks of short duration.
None of these task/structure recommendations have been tested in a software development environment.
== Rival concepts ==
Egoless programming explicitly minimizes constraints of hierarchy and status so as to enable the free exchange of ideas and improvements. It may be contrasted with the chief programmer team concept which emphasises specialisation and leadership in teams so that they work in a more disciplined way.
== See also ==
List of software development philosophies
Software review
Egolessness
== References ==
== External links ==
The Ten Commandments of Egoless Programming
|
https://en.wikipedia.org/wiki/Egoless_programming
|
Comment programming, also known as comment-driven development (CDD), is a (mostly) satirical software development technique that is heavily based on commenting out code.
In comment programming, the comment tags are not used to describe what a certain piece of code is doing, but rather to stop some parts of the code from being executed. The aim is to have the commented code at the developer's disposal at any time it might be needed. This is especially useful when the requirements change rapidly. In this case, they happen to revert to older versions of themselves, thus making the programmer either write the code again, or revert parts of the code from the versioning repository, which would be more time-consuming. With comment programming, when such a request for reverting to an old implementation arises, the developer just comments out the current implementation and uncomments the previous. It is advisable to add short descriptive comments to blocks of commented code.
== Practical uses ==
When it comes to a work environment, it isn't about who knows the most terms out of a textbook. Instead, we are faced with problems that we aren't sure how to solve. When someone else reads a users' program, it is important for them to understand how the problem was gone about and not just to see the answer. Even if someone decides to go into something other than computer programming, they will be well equipped with the habit of comments and showing others how they thought and solved specific problems.
A related, but separate, more practical use of comments is for creating stubs with comments describing a feature (usually using special tags) ahead of future development of that feature.
For example, this programming process can be used for prototyping a new design pattern. This is done by creating a new structure of classes or functions without any implementation and adding the implementation at a later date.
Studies show that there are mainly two types of comments being used across programs. Preconditional and Postconditional are the two biggest ideas that computer programmers should use when developing projects. Preconditional comes before the function or method have been written. They are used to describe what each block of code is supposed to do. This can guide users in the right direction if someone is trying to debug or dissect code. Postconditional comments are used after the function or set of statements have been written. They are generally used to explain to the reader why they chose to go about the problem in that manner.
Pseudocode Example:
In the example, there is a structure around a click event handler. However, comment programming is used instead of a real implementation. The idea is that many functions can be written like this, and then the design can be reworked and revisited without having to refactor a lot of source code.
== Popular culture ==
MSDN Sweden produced a video for April Fools' Day 2010, where they satirically presented CDD as if it were a serious methodology.
MCT is a tool made for programmers in order to help relieve some of the complexity in computer code. Instead of normal comments, this tool allows the addition of videos, animations, images, and voiceovers. Users are able to download this software online and can add these tools by using the cursor to drag over the line or lines they want to explain. Users are also able to add audio or hand gestures as comments. This can help explain the reasoning behind functions and how a program executes.
== References ==
|
https://en.wikipedia.org/wiki/Comment_programming
|
Programming complexity (or software complexity) is a term that includes software properties that affect internal interactions. Several commentators distinguish between the terms "complex" and "complicated". Complicated implies being difficult to understand, but ultimately knowable. Complex, by contrast, describes the interactions between entities. As the number of entities increases, the number of interactions between them increases exponentially, making it impossible to know and understand them all. Similarly, higher levels of complexity in software increase the risk of unintentionally interfering with interactions, thus increasing the risk of introducing defects when changing the software. In more extreme cases, it can make modifying the software virtually impossible.
The idea of linking software complexity to software maintainability has been explored extensively by Professor Manny Lehman, who developed his Laws of Software Evolution. He and his co-author Les Belady explored numerous software metrics that could be used to measure the state of software, eventually concluding that the only practical solution is to use deterministic complexity models.
== Types ==
The complexity of an existing program determines the complexity of changing the program. Problem complexity can be divided into two categories:
Accidental complexity relates to difficulties a programmer faces due to the software engineering tools. Selecting a better tool set or a higher-level programming language may reduce it. Accidental complexity often results from not using the domain to frame the form of the solution. Domain-driven design can help minimize accidental complexity.
Essential complexity is caused by the characteristics of the problem to be solved and cannot be reduced.
== Measures ==
Several measures of software complexity have been proposed. Many of these, although yielding a good representation of complexity, do not lend themselves to easy measurement. Some of the more commonly used metrics are
McCabe's cyclomatic complexity metric
Halstead's software science metrics
Henry and Kafura introduced "Software Structure Metrics Based on Information Flow" in 1981, which measures complexity as a function of "fan-in" and "fan-out". They define fan-in of a procedure as the number of local flows into that procedure plus the number of data structures from which that procedure retrieves information. Fan-out is defined as the number of local flows out of that procedure plus the number of data structures that the procedure updates. Local flows relate to data passed to, and from procedures that call or are called by, the procedure in question. Henry and Kafura's complexity value is defined as "the procedure length multiplied by the square of fan-in multiplied by fan-out" (Length ×(fan-in × fan-out)²).
Chidamber and Kemerer introduced "A Metrics Suite for Object-Oriented Design" in 1994, focusing on metrics for object-oriented code. They introduce six OO complexity metrics: (1) weighted methods per class; (2) coupling between object classes; (3) response for a class; (4) number of children; (5) depth of inheritance tree; and (6) lack of cohesion of methods.
Several other metrics can be used to measure programming complexity:
Branching complexity (Sneed Metric)
Data access complexity (Card Metric)
Data complexity (Chapin Metric)
Data flow complexity (Elshof Metric)
Decisional complexity (McClure Metric)
Path Complexity (Bang Metric)
Tesler's Law is an adage in human–computer interaction stating that every application has an inherent amount of complexity that cannot be removed or hidden.
== Chidamber and Kemerer Metrics ==
Chidamber and Kemerer proposed a set of programing complexity metrics widely used in measurements and academic articles: weighted methods per class, coupling between object classes, response for a class, number of children, depth of inheritance tree, and lack of cohesion of methods, described below:
Weighted methods per class ("WMC")
|
https://en.wikipedia.org/wiki/Programming_complexity
|
In programming, a gotcha is a valid construct in a system, program or programming language that works as documented but is counter-intuitive and almost invites mistakes because it is both easy to invoke and unexpected or unreasonable in its outcome.
== Example ==
The classic gotcha in C/C++ is the construct
It is syntactically valid: it puts the value of b into a and then executes code if a is non-zero. Sometimes this is even intended. However most commonly it is a typo: the programmer probably meant
which executes code if a and b are equal. Modern compilers will usually generate a warning when encountering the former construct (conditional branch on assignment, not comparison), depending on compiler options (e.g., the -Wall option for gcc). To avoid this gotcha, some programming languages such include specific syntax for when this is desired behavior, such as Python's "walrus" operator (:=). In languages where this specific syntax does not exist, there is a recommendation to keep the constants in the left side of the comparison, e.g. 42 == x rather than x == 42. This way, using = instead of == will cause a compiler error (see Yoda conditions). Many kinds of gotchas are not detected by compilers, however.
== See also ==
Usability
== References ==
== Further reading ==
Stephen C. Dewhurst (2003). C++ Gotchas (Avoiding Common Problems in Coding and Design). Addison-Wesley. ISBN 0321125185.
== External links ==
C Traps and Pitfalls by Andrew Koenig
C++ Gotchas A programmer's guide to avoiding and correcting ninety-nine of the most common, destructive, and interesting C++ design and programming errors, by Stephen C. Dewhurst
|
https://en.wikipedia.org/wiki/Gotcha_(programming)
|
In software engineering, "programming in the large" and "programming in the small" refer to two different aspects of writing software. "Programming in the large" means designing a larger system as a composition of smaller parts, and "programming in the small" means creating those smaller parts by writing lines of code in a programming language.
The terms were coined by Frank DeRemer and Hans Kron in their 1975 paper "Programming-in-the-large versus programming-in-the-small", in which they argue that the two are essentially different activities, and that typical programming languages, and the practice of structured programming, provide good support for the latter, but not for the former.
This may be compared to the later Ousterhout's dichotomy, which distinguishes between system programming languages (for components) and scripting languages (for glue code, connecting components).
== Description ==
Fred Brooks identifies that the way an individual program is created is different from how a programming systems product is created. The former likely does one relatively simple task well. It is probably coded by a single engineer, is complete in itself, and is ready to run on the system on which it was developed. The programming activity was probably fairly short-lived as simple tasks are quick and easy to complete. This is the endeavor that DeRemer and Kron describe as programming in the small.
Compare with the activities associated with a programming systems project, again as identified by Brooks. Such a project is typified by medium-sized or large industrial teams working on the project for many months to several years. The project is likely to be split up into several or hundreds of separate modules which individually are of a similar complexity to the individual programs described above. However, each module will define an interface to its surrounding modules.
Brooks describes how programming systems projects are typically run as formal projects that follow industry best practices and will comprise testing, documentation and ongoing maintenance activities as well as activities to ensure that the product is generalized to work in different scenarios including on systems other than the development systems on which it was created.
== Programming in the large ==
In software development, programming in the large can involve programming by larger groups of people or by smaller groups over longer time periods. Either of these conditions will result in large, and hence complicated, programs that can be challenging for maintainers to understand.
With programming in the large, coding managers place emphasis on partitioning work into modules with precisely-specified interactions. This requires careful planning and documentation.
With programming in the large, program changes can become difficult. If a change operates across module boundaries, the work of many people may need re-doing. Because of this, one goal of programming in the large involves setting up modules that will not need altering in the event of probable changes. This is achieved by designing modules so they have high cohesion and loose coupling.
Programming in the large requires management skills. The process of building abstractions aims not just to describe something that can work but also to direct the efforts of people who will make it work.
The concept was introduced by Frank DeRemer and Hans Kron in their 1975 paper "Programming-in-the-Large Versus Programming-in-the-Small", IEEE Trans. on Soft. Eng. 2(2).
In computer science terms, programming in the large can refer to programming code that represents the high-level state transition logic of a system. This logic encodes information such as when to wait for messages, when to send messages, when to compensate for failed non-ACID transactions, etc.
A language that was designed to explicitly support programming in the large is BPEL.
== Programming in the small ==
In software development, programming in the small desc
|
https://en.wikipedia.org/wiki/Programming_in_the_large_and_programming_in_the_small
|
glob() () is a libc function for globbing, which is the archetypal use of pattern matching against the names in a filesystem directory such that a name pattern is expanded into a list of names matching that pattern. Although globbing may now refer to glob()-style pattern matching of any string, not just expansion into a list of filesystem names, the original meaning of the term is still widespread.
The glob() function and the underlying gmatch() function originated at Bell Labs in the early 1970s alongside the original AT&T UNIX itself and had a formative influence on the syntax of UNIX command line utilities and therefore also on the present-day reimplementations thereof.
In their original form, glob() and gmatch() derived from code used in Bell Labs in-house utilities that developed alongside the original Unix in the early 1970s. Among those utilities were also two command line tools called glob and find; each could be used to pass a list of matching filenames to other command line tools, and they shared the backend code subsequently formalized as glob() and gmatch(). Shell-statement-level globbing by default became commonplace following the "builtin"-integration of globbing-functionality into the 7th edition of the Unix shell in 1978. The Unix shell's -f option to disable globbing — i.e. revert to literal "file" mode — appeared in the same version.
The glob pattern quantifiers now standardized by POSIX.2 (IEEE Std 1003.2) fall into two groups, and can be applied to any character sequence ("string"), not just to directory entries.
"Metacharacters" (also called "Wildcards"):
? (not in brackets) matches any character exactly once.
* (not in brackets) matches a string of zero or more characters.
"Ranges/sets":
[...], where the first character within the brackets is not '!', matches any single character among the characters specified in the brackets. If the first character within brackets is '!', then the [!...] matches any single character that is not among the characters specified in the brackets.
The characters in the brackets may be a list ([abc]) or a range ([a-c]) or denote a character class (like [[:space:]] where the inner brackets are part of the classname). POSIX does not mandate multi-range ([a-c0-3]) support, which derive originally from regular expressions.
As reimplementations of Bell Labs' UNIX proliferated, so did reimplementations of its Bell Labs' libc and shell, and with them glob() and globbing. Today, glob() and globbing are standardized by the POSIX.2 specification and are integral part of every Unix-like libc ecosystem and shell, including AT&T Bourne shell-compatible Korn shell (ksh), Z shell (zsh), Almquist shell (ash) and its derivatives and reimplementations such as busybox, toybox, GNU bash, Debian dash.
== Origin ==
The glob command, short for global, originates in the earliest versions of Bell Labs' Unix. The command interpreters of the early versions of Unix (1st through 6th Editions, 1969–1975) relied on a separate program to expand wildcard characters in unquoted arguments to a command: /etc/glob. That program performed the expansion and supplied the expanded list of file paths to the command for execution.
Glob was originally written in the B programming language. It was the first piece of mainline Unix software to be developed in a high-level programming language. Later, this functionality was provided as a C library function, glob(), used by programs such as the shell. It is usually defined based on a function named fnmatch(), which tests for whether a string matches a given pattern - the program using this function can then iterate through a series of strings (usually filenames) to determine which ones match. Both functions are a part of POSIX: the functions defined in POSIX.1 since 2001, and the syntax defined in POSIX.2. The idea of defining a separate match function started with wildmat (wildcard match), a simple library to match strings against Bourne Shell globs.
Traditionally, globs
|
https://en.wikipedia.org/wiki/Glob_(programming)
|
A programming model is an execution model coupled to an API or a particular pattern of code. In this style, there are actually two execution models in play: the execution model of the base programming language and the execution model of the programming model. An example is Spark where Java is the base language, and Spark is the programming model. Execution may be based on what appear to be library calls. Other examples include the POSIX Threads library and Hadoop's MapReduce. In both cases, the execution model of the programming model is different from that of the base language in which the code is written. For example, the C programming language has no behavior in its execution model for input/output or thread behavior. But such behavior can be invoked from C syntax, by making what appears to be a call to a normal C library.
What distinguishes a programming model from a normal library is that the behavior of the call cannot be understood in terms of the language the program is written in. For example, the behavior of calls to the POSIX thread library cannot be understood in terms of the C language. The reason is that the call invokes an execution model that is different from the execution model of the language. This invocation of an outside execution model is the defining characteristic of a programming model, in contrast to a programming language.
In parallel computing, the execution model often must expose features of the hardware in order to achieve high performance. The large amount of variation in parallel hardware causes a concurrent need for a similarly large number of parallel execution models. It is impractical to make a new language for each execution model, hence it is a common practice to invoke the behaviors of the parallel execution model via an API. So, most of the programming effort is done via parallel programming models rather than parallel languages. The terminology around such programming models tends to focus on the details of the hardware that inspired the execution model, and in that insular world the mistaken belief is formed that a programming model is only for the case when an execution model is closely matched to hardware features.
== References ==
|
https://en.wikipedia.org/wiki/Programming_model
|
Systems programming, or system programming, is the activity of programming computer system software. The primary distinguishing characteristic of systems programming when compared to application programming is that application programming aims to produce software which provides services to the user directly (e.g. word processor), whereas systems programming aims to produce software and software platforms which provide services to other software, are performance constrained, or both (e.g. operating systems, computational science applications, game engines, industrial automation, and software as a service applications).
Systems programming requires a great degree of hardware awareness. Its goal is to achieve efficient use of available resources, either because the software itself is performance-critical or because even small efficiency improvements directly transform into significant savings of time or money.
== Overview ==
The following attributes characterize systems programming:
The programmer can make assumptions about the hardware and other properties of the system that the program runs on, and will often exploit those properties, for example by using an algorithm that is known to be efficient when used with specific hardware.
Usually a low-level programming language or programming language dialect is used so that:
Programs can operate in resource-constrained environments
Programs can be efficient with little runtime overhead, possibly having either a small runtime library or none at all
Programs may use direct and "raw" control over memory access and control flow
The programmer may write parts of the program directly in assembly language
Often systems programs cannot be run in a debugger. Running the program in a simulated environment can sometimes be used to reduce this problem.
In systems programming, often limited programming facilities are available. The use of automatic garbage collection is not common and debugging is sometimes hard to do. The runtime library, if available at all, is usually far less powerful, and does less error checking. Because of those limitations, monitoring and logging are often used; operating systems may have extremely elaborate logging subsystems.
Implementing certain parts in operating systems and networking requires systems programming, for example implementing paging (virtual memory) or a device driver for an operating system.
== History ==
Originally systems programmers invariably wrote in assembly language. Experiments with hardware support in high level languages in the late 1960s led to such languages as PL/S, BLISS, BCPL, and extended ALGOL for Burroughs large systems. Forth also has applications as a systems language.
In the 1970s, C became widespread, aided by the growth of Unix.
More recently a subset of C++ called Embedded C++ has seen some use, for instance it is used in the I/O Kit drivers of macOS.
Engineers working at Google created Go in 2007 to address developer productivity in large distributed systems, with developer-focused features such as Concurrency, Garbage Collection, and faster program compilation than C and C++.
In 2015 Rust came out, a general-purpose programming language often used in systems programming. Rust was designed with memory safety in mind and to be as performant as C and C++.
== Alternative meaning ==
For historical reasons, some organizations use the term systems programmer to describe a job function which would be more accurately termed systems administrator. This is particularly true in organizations whose computer resources have historically been dominated by mainframes, although the term is even used to describe job functions which do not involve mainframes. This usage arose because administration of IBM mainframes often involved the writing of custom assembler code (IBM's Basic Assembly Language (BAL)), which integrated with the operating system such as OS/MVS, DOS/VSE or VM/CMS. Indeed, some IBM software products had substantial code
|
https://en.wikipedia.org/wiki/Systems_programming
|
Radio programming is the process of organising a schedule of radio content for commercial broadcasting and public broadcasting by radio stations.
== History ==
The original inventors of radio, from Guglielmo Marconi's time on, expected it to be used for one-on-one wireless communication tasks where telephones and telegraphs could not be used because of the problems involved in stringing copper wires from one point to another, such as in ship-to-shore communications. Those inventors had no expectations whatever that radio would become a major mass media entertainment and information medium earning many millions of dollars in revenues annually through radio advertising commercials or sponsorship. These latter uses were brought about after 1920 by business entrepreneurs such as David Sarnoff, who created the National Broadcasting Company (NBC), and William S. Paley, who built Columbia Broadcasting System (CBS). These broadcasting (as opposed to narrowcasting) business organizations began to be called network affiliates, because they consisted of loose chains of individual stations located in various cities, all transmitting the standard overall-system supplied fare, often at synchronised agreed-upon times. Some of these radio network stations were owned and operated by the networks, while others were independent radio owned by entrepreneurs allied with the respective networks. By selling blocks of time to advertisers, the medium was able to quickly become profitable and offer its products to listeners for free, provided they invested in a radio receiver set.
The new medium had grown rapidly through the 1930s, vastly increasing both the size of its audience and its profits. In those early days, it was customary for a corporation to sponsor an entire half-hour radio program, placing its commercials at the beginning and the end. This is in contrast to the pattern which developed late in the 20th century in both television and radio, where small slices of time were sold to many sponsors and no corporation claimed or wanted sponsorship of the entire show, except in rare cases. These later commercials also filled a much larger portion of the total program time than they had in the earlier days.
In the early radio age, content typically included a balance of comedy, drama, news, music and sports reporting. Variety radio programs included the most famous Hollywood talent of the day. During the 1920s, radio focused on musical entertainment, the Grand Ole Opry, has been focused on broadcasting country music since it began in 1925. Radio soap operas began in the U.S. in 1930 with Painted Dreams. Lørdagsbarnetimen, a Norwegian children's show, with its premiere in 1924 interrupted only by the Second World War, was the longest running radio show in the world until it ceased production in 2010.
In the early 1950s, television programming eroded the popularity of radio comedy, drama and variety shows. By the late 1950s, radio broadcasting took on much the form it has today – strongly focused on music, talk, news and sports, though drama can still be heard, especially on the BBC.
== References ==
|
https://en.wikipedia.org/wiki/Radio_programming
|
In computer programming, a parameter, a.k.a. formal argument, is a variable that represents an argument, a.k.a. actual argument, a.k.a. actual parameter, to a subroutine call.. A function's signature defines its parameters. A call invocation involves evaluating each argument expression of a call and associating the result with the corresponding parameter.
For example, consider subroutine def add(x, y): return x + y. Variables x and y are parameters. For call add(2, 3), the expressions 2 and 3 are arguments. For call add(a+1, b+2), the arguments are a+1 and b+2.
Parameter passing is defined by a programming language. Evaluation strategy defines the semantics for how parameters can be declared and how arguments are passed to a subroutine. Generally, with call by value, a parameter acts like a new, local variable initialized to the value of the argument. If the argument is a variable, the subroutine cannot modify the argument state because the parameter is a copy. With call by reference, which requires the argument to be a variable, the parameter is an alias of the argument.
== Example ==
The following program defines a function named SalesTax with one parameter named price; both typed double.
For call SalesTax(10.00), the argument 10.00 is evaluated to a double value (10) and assigned to parameter variable price. The function is executed and returns the value 0.5.
== Parameters and arguments ==
The terms parameter and argument may have different meanings in different programming languages. Sometimes they are used interchangeably, and the context is used to distinguish the meaning. The term parameter (sometimes called formal parameter) is often used to refer to the variable as found in the function declaration, while argument (sometimes called actual parameter) refers to the actual input supplied at a function call statement. For example, if one defines a function as def f(x): ..., then x is the parameter, and if it is called by a = ...; f(a) then a is the argument. A parameter is an (unbound) variable, while the argument can be a literal or variable or more complex expression involving literals and variables. In case of call by value, what is passed to the function is the value of the argument – for example, f(2) and a = 2; f(a) are equivalent calls – while in call by reference, with a variable as argument, what is passed is a reference to that variable - even though the syntax for the function call could stay the same. The specification for pass-by-reference or pass-by-value would be made in the function declaration and/or definition.
Parameters appear in procedure definitions; arguments appear in procedure calls. In the function definition f(x) = x*x the variable x is a parameter; in the function call f(2) the value 2 is the argument of the function. Loosely, a parameter is a type, and an argument is an instance.
A parameter is an intrinsic property of the procedure, included in its definition. For example, in many languages, a procedure to add two supplied integers together and calculate the sum would need two parameters, one for each integer. In general, a procedure may be defined with any number of parameters, or no parameters at all. If a procedure has parameters, the part of its definition that specifies the parameters is called its parameter list.
By contrast, the arguments are the expressions supplied to the procedure when it is called, usually one expression matching one of the parameters. Unlike the parameters, which form an unchanging part of the procedure's definition, the arguments may vary from call to call. Each time a procedure is called, the part of the procedure call that specifies the arguments is called the argument list.
Although parameters are also commonly referred to as arguments, arguments are sometimes thought of as the actual values or references assigned to the parameter variables when the subroutine is called at run-time. When discussing code that is calling into a subroutine, any values or
|
https://en.wikipedia.org/wiki/Parameter_(computer_programming)
|
R is a programming language for statistical computing and data visualization. It has been adopted in the fields of data mining, bioinformatics and data analysis/data science.
The core R language is augmented by a large number of extension software packages, which contain reusable code, documentation, and sample data.
R software is open-source and free software. R is a GNU Project and licensed under the GNU General Public License. It is written primarily in C, Fortran, and R itself. Precompiled executables are provided for various operating systems.
As an interpreted language, R has a native command line interface. Moreover, multiple third-party graphical user interfaces are available, such as RStudio—an integrated development environment—and Jupyter—a notebook interface.
== History ==
R was started by professors Ross Ihaka and Robert Gentleman as a programming language to teach introductory statistics at the University of Auckland. The language was inspired by the S programming language, with most S programs able to run unaltered in R. The language was also inspired by Scheme's lexical scoping, allowing for local variables.
The name of the language, R, comes from being both an S language successor as well as the shared first letter of the authors, Ross and Robert. In August 1993, Ihaka and Gentleman posted a binary of R on StatLib — a data archive website. At the same time, they announced the posting on the s-news mailing list. On 5 December 1997, R became a GNU project when version 0.60 was released. On 29 February 2000, the 1.0 version was released.
== Packages ==
R packages are collections of functions, documentation, and data that expand R. For example, packages can add reporting features (using packages like RMarkdown, Quarto, knitr, and Sweave) and the capability to implement various statistical techniques (such as linear, generalized linear and nonlinear modeling, classical statistical tests, spatial analysis, time-series analysis, and clustering). Perceived easy package installation and usability have contributed to the language's adoption in data science.
Immediately available when starting R, base packages provide the basic and necessary syntax and commands for programming, computing, graphics production, basic arithmetic, and statistical functionality.
An example R package is the tidyverse package, which bundles several subsidiary packages to provide a common interface. It specializes in tasks related to accessing and processing "tidy data", which are data contained in a two-dimensional table with a single row for each observation and a single column for each variable.
Installing a package occurs only once. For example, to install the tidyverse package:
To load the functions, data, and documentation of a package, one executes the library() function. To load tidyverse:
The Comprehensive R Archive Network (CRAN) was founded in 1997 by Kurt Hornik and Friedrich Leisch to host R's source code, executable files, documentation, and user-created packages. Its name and scope mimic the Comprehensive TeX Archive Network (CTAN) and the Comprehensive Perl Archive Network (CPAN). CRAN originally had three mirroring sites and twelve contributed packages. As of 16 October 2024, it has 99 mirrors and 21,513 contributed packages. Packages are also available on repositories like R-Forge, Omegahat, and GitHub.
On the CRAN web site as a form of guidance, Task Views lists packages on CRAN that are relevant for tasks related to a certain topics, such as causal inference, finance, genetics, high-performance computing, machine learning, medical imaging, meta-analysis, social sciences, and spatial statistics.
The Bioconductor project provides packages for genomic data analysis, complementary DNA, microarray, and high-throughput sequencing methods.
== Community ==
There are three main groups that help support R software development:
The R Core Team was founded in 1997 to maintain the R source code.
The R Foundation for Statistical
|
https://en.wikipedia.org/wiki/R_(programming_language)
|
Parametric programming is a type of mathematical optimization, where the optimization problem is solved as a function of one or multiple parameters. Developed in parallel to sensitivity analysis, its earliest mention can be found in a thesis from 1952. Since then, there have been considerable developments for the cases of multiple parameters, presence of integer variables as well as nonlinearities.
== Notation ==
In general, the following optimization problem is considered
J
∗
(
θ
)
=
min
x
∈
R
n
f
(
x
,
θ
)
subject to
g
(
x
,
θ
)
≤
0.
θ
∈
Θ
⊂
R
m
{\displaystyle {\begin{aligned}J^{*}(\theta )=&\min _{x\in \mathbb {R} ^{n}}f(x,\theta )\\&{\text{subject to }}g(x,\theta )\leq 0.\\&\theta \in \Theta \subset \mathbb {R} ^{m}\end{aligned}}}
where
x
{\displaystyle x}
is the optimization variable,
θ
{\displaystyle \theta }
are the parameters,
f
(
x
,
θ
)
{\displaystyle f(x,\theta )}
is the objective function and
g
(
x
,
θ
)
{\displaystyle g(x,\theta )}
denote the constraints.
J
∗
{\displaystyle J^{*}}
denotes a function whose output is the optimal value of the objective function
f
{\displaystyle f}
. The set
Θ
{\displaystyle \Theta }
is generally referred to as parameter space.
The optimal value (i.e. result of solving the optimization problem) is obtained by evaluating the function with an argument
θ
{\displaystyle \theta }
.
== Classification ==
Depending on the nature of
f
(
x
,
θ
)
{\displaystyle f(x,\theta )}
and
g
(
x
,
θ
)
{\displaystyle g(x,\theta )}
and whether the optimization problem features integer variables, parametric programming problems are classified into different sub-classes:
If more than one parameter is present, i.e.
m
>
1
{\displaystyle m>1}
, then it is often referred to as multiparametric programming problem
If integer variables are present, then the problem is referred to as (multi)parametric mixed-integer programming problem
If constraints are affine, then additional classifications depending to nature of the objective function in (
|
https://en.wikipedia.org/wiki/Parametric_programming
|
An esoteric programming language (sometimes shortened to esolang) is a programming language designed to test the boundaries of computer programming language design, as a proof of concept, as software art, as a hacking interface to another language (particularly functional programming or procedural programming languages), or as a joke. The use of the word esoteric distinguishes them from languages that working developers use to write software. The creators of most esolangs do not intend them to be used for mainstream programming, although some esoteric features, such as visuospatial syntax, have inspired practical applications in the arts. Such languages are often popular among hackers and hobbyists.
Usability is rarely a goal for designers of esoteric programming languages; often their design leads to quite the opposite. Their usual aim is to remove or replace conventional language features while still maintaining a language that is Turing-complete, or even one for which the computational class is unknown.
== History ==
The earliest, and still the canonical example of an esoteric programming language, is INTERCAL, designed in 1972 by Don Woods and James M. Lyon, who said that their intention was to create a programming language unlike any with which they were familiar. It parodied elements of established programming languages of the day such as Fortran, COBOL and assembly language.
For many years, INTERCAL was represented only by paper copies of the INTERCAL manual. Its revival in 1990 as an implementation in C under Unix stimulated a wave of interest in the intentional design of esoteric computer languages.
In 1993, Wouter van Oortmerssen created FALSE, a small stack-oriented programming language with syntax designed to make the code inherently obfuscated, confusing and unreadable. Its compiler is only 1024 bytes in size. This inspired Urban Müller to create an even smaller language, the now-infamous Brainfuck, which consists of only eight recognized characters. Along with Chris Pressey's Befunge (like FALSE, but with a two-dimensional instruction pointer), Brainfuck is now one of the best-supported esoteric programming languages, with canonical examples of minimal Turing tarpits and needlessly obfuscated language features. Brainfuck is related to the P′′ family of Turing machines.
== Common features ==
While esoteric programming languages differ in many ways, there are some common traits that characterize many languages, such as parody, minimalism, and the goal of making programming difficult. Many esoteric programming languages, such as brainfuck, and similar, use single characters as commands, however, it is not uncommon for languages to read line by line like conventional programming languages.
=== Unique data representations ===
Conventional imperative programming languages typically allow data to be stored in variables, but esoteric languages may utilize different methods of storing and accessing data. Languages like Brainfuck and Malbolge only permit data to be read through a single pointer, which must be moved to a location of interest before data is read. Others, like Befunge and Shakespeare, utilize one or more stacks to hold data, leading to a manner of execution akin to Reverse Polish notation. Finally, there are languages which explore alternative forms of number representation: the Brainfuck variant Boolfuck only permits operations on single bits, while Malbolge and INTERCAL variant TriINTERCAL replace bits altogether with a base 3 ternary system.
=== Unique instruction representations ===
Esoteric languages also showcase unique ways of representing program instructions. Some languages, such as Befunge and Piet, represent programs in two or more dimensions, with program control moving around in multiple possible directions through the program. This differs from conventional languages in which a program is a set of instructions usually encountered in sequence. Other languages modify instructions to appe
|
https://en.wikipedia.org/wiki/Esoteric_programming_language
|
A programmer, computer programmer or coder is an author of computer source code – someone with skill in computer programming.
The professional titles software developer and software engineer are used for jobs that require a programmer.
== Identification ==
Sometimes a programmer or job position is identified by the language used or target platform. For example, assembly programmer, web developer.
== Job title ==
The job titles that include programming tasks have differing connotations across the computer industry and to different individuals. The following are notable descriptions.
A software developer primarily implements software based on specifications and fixes bugs. Other duties may include reviewing code changes and testing.
To achieve the required skills for the job, they might obtain a computer science or associate degree, attend a programming boot camp or be self-taught.
A software engineer usually is responsible for the same tasks as a developer
plus broader responsibilities of software engineering including architecting and designing new features and applications, targeting new platforms, managing the software development lifecycle (design, implementation, testing, and deployment), leading a team of programmers, communicating with customers, managers and other engineers, considering system stability and quality, and exploring software development methodologies.
Sometimes, a software engineer is required to have a degree in software engineering, computer engineering, or computer science. Some countries legally require an engineering degree to be called engineer.
== History ==
British countess and mathematician Ada Lovelace is often considered to be the first computer programmer.
She authored an algorithm, which was published in October 1842, for calculating Bernoulli numbers on the Charles Babbage analytical engine.
Because the machine was not completed in her lifetime, she never experienced the algorithm in action.
In 1941, German civil engineer Konrad Zuse was the first person to execute a program on a working, program-controlled, electronic computer. From 1943 to 1945, per computer scientist Wolfgang K. Giloi and AI professor Raúl Rojas et al., Zuse created the first, high-level programming language, Plankalkül.
Members of the 1945 ENIAC programming team of Kay McNulty, Betty Jennings, Betty Snyder, Marlyn Wescoff, Fran Bilas and Ruth Lichterman have since been credited as the first professional computer programmers.
== The software industry ==
The first company founded specifically to provide software products and services was the Computer Usage Company in 1955. Before that time, computers were programmed either by customers or the few commercial computer manufacturers of the time, such as Sperry Rand and IBM.
The software industry expanded in the early 1960s, almost immediately after computers were first sold in mass-produced quantities. Universities, governments, and businesses created a demand for software. Many of these programs were written in-house by full-time staff programmers; some were distributed between users of a particular machine for no charge, while others were sold on a commercial basis. Other firms, such as Computer Sciences Corporation (founded in 1959), also started to grow. Computer manufacturers soon started bundling operating systems, system software and programming environments with their machines; the IBM 1620 came with the 1620 Symbolic Programming System and FORTRAN.
The industry expanded greatly with the rise of the personal computer (PC) in the mid-1970s, which brought computing to the average office worker. In the following years, the PC also helped create a constantly growing market for games, applications and utility software. This resulted in increased demand for software developers for that period of time.
== Nature of the work ==
Computer programmers write, test, debug, and maintain the detailed instructions, called computer programs, that computers must follow to
|
https://en.wikipedia.org/wiki/Programmer
|
In computer programming, flag can refer to one or more bits that are used to store a binary value or a Boolean variable for signaling special code conditions, such as file empty or full queue statuses.
Flags may be found as members of a defined data structure, such as a database record, and the meaning of the value contained in a flag will generally be defined in relation to the data structure it is part of. In many cases, the binary value of a flag will be understood to represent one of several possible states or statuses. In other cases, the binary values may represent one or more attributes in a bit field, often related to abilities or permissions, such as "can be written to" or "can be deleted". However, there are many other possible meanings that can be assigned to flag values. One common use of flags is to mark or designate data structures for future processing.
Within microprocessors and other logic devices, flags are commonly used to control or indicate the intermediate or final state or outcome of different operations. Microprocessors typically have, for example, a status register that is composed of such flags, and the flags are used to indicate various post-operation conditions, such as when there has been an arithmetic overflow. The flags can be utilized in subsequent operations, such as in processing conditional jump instructions. For example a je (Jump if Equal) instruction in the x86 assembly language will result in a jump if the Z (zero) flag was set by some previous operation.
A command line switch is also referred to as a "flag". Command line programs often start with an option parser that translates command line switches into flags in the sense of this article.
== See also ==
Bit field
Control register
Enumerated type
FLAGS register (computing)
Program status word
Semaphore (programming)
Status register
== References ==
|
https://en.wikipedia.org/wiki/Flag_(programming)
|
Structured programming is a programming paradigm aimed at improving the clarity, quality, and development time of a computer program by making specific disciplined use of the structured control flow constructs of selection (if/then/else) and repetition (while and for), block structures, and subroutines.
It emerged in the late 1950s with the appearance of the ALGOL 58 and ALGOL 60 programming languages, with the latter including support for block structures. Contributing factors to its popularity and widespread acceptance, at first in academia and later among practitioners, include the discovery of what is now known as the structured program theorem in 1966, and the publication of the influential "Go To Statement Considered Harmful" open letter in 1968 by Dutch computer scientist Edsger W. Dijkstra, who coined the term "structured programming".
Structured programming is most frequently used with deviations that allow for clearer programs in some particular cases, such as when exception handling has to be performed.
== Elements ==
=== Control structures ===
Following the structured program theorem, all programs are seen as composed of three control structures:
"Sequence"; ordered statements or subroutines executed in sequence.
"Selection"; one of a number of statements is executed depending on the state of the program. This is usually expressed with keywords such as if..then..else..endif. The conditional statement should have at least one true condition and each condition should have one exit point at max.
"Iteration"; a statement or block is executed until the program reaches a certain state, or operations have been applied to every element of a collection. This is usually expressed with keywords such as while, repeat, for or do..until. Often it is recommended that each loop should only have one entry point (and in the original structural programming, also only one exit point, and a few languages enforce this).
=== Subroutines ===
Subroutines; callable units such as procedures, functions, methods, or subprograms are used to allow a sequence to be referred to by a single statement.
=== Blocks ===
Blocks are used to enable groups of statements to be treated as if they were one statement. Block-structured languages have a syntax for enclosing structures in some formal way, such as an if-statement bracketed by if..fi as in ALGOL 68, or a code section bracketed by BEGIN..END, as in PL/I and Pascal, whitespace indentation as in Python, or the curly braces {...} of C and many later languages.
== Structured programming languages ==
It is possible to do structured programming with any programming language enabling code blocks and the three types of control structures, even though a procedural programming language is able to break the structure. Some of the languages initially used for structured programming include: ALGOL, Pascal, PL/I, Ada and RPL but most new procedural programming languages since that time have included features to encourage structured programming, and sometimes deliberately left out features – notably GOTO – in an effort to make unstructured programming more difficult.
Structured programming (sometimes known as modular programming) enforces a logical structure on the program being written to make it more efficient and easier to understand and modify.
== History ==
=== Theoretical foundation ===
The structured program theorem provides the theoretical basis of structured programming. It states that three ways of combining programs—sequencing, selection, and iteration—are sufficient to express any computable function. This observation did not originate with the structured programming movement; these structures are sufficient to describe the instruction cycle of a central processing unit, as well as the operation of a Turing machine. Therefore, a processor is always executing a "structured program" in this sense, even if the instructions it reads from memory are not part of a structured program. However,
|
https://en.wikipedia.org/wiki/Structured_programming
|
The Public Broadcasting Service (PBS) is an American public broadcaster and non-commercial, free-to-air television network based in Arlington, Virginia. PBS is a publicly funded nonprofit organization and the most prominent provider of educational programs to public television stations in the United States, distributing shows such as Frontline, Nova, PBS News Hour, Masterpiece, Mister Rogers' Neighborhood, Sesame Street, Barney & Friends and American Experience. Certain stations also provide spillover service to Canada.
PBS is funded by a combination of member station dues, the Corporation for Public Broadcasting, pledge drives, and donations from both private foundations and individual citizens. All proposed funding for programming is subject to a set of standards to ensure the program is free of influence from the funding source. PBS has over 350 member television stations, many owned by educational institutions, nonprofit groups both independent or affiliated with one particular local public school district or collegiate educational institution, or entities owned by or related to state government.
== History ==
PBS was established on November 3, 1969, by Hartford N. Gunn Jr. (president of WGBH), John Macy (president of CPB), James Day (last president of National Educational Television), and Kenneth A. Christiansen (chairman of the department of broadcasting at the University of Florida).
It began operations on October 5, 1970, taking over many of the functions of its predecessor, National Educational Television (NET), which later merged with Newark, New Jersey station WNDT to form WNET. In 1973, it merged with Educational Television Stations. Around the same time, the groups started out the National Public Affairs Broadcast Center (later National Public Affairs Center for Television), which offered news and national affairs to the service. The group was later merged into member station WETA-TV in 1972.
Immediately after public disclosure of the Watergate scandal, on May 17, 1973, the United States Senate Watergate Committee commenced proceedings; PBS broadcast the proceedings nationwide, with Robert MacNeil and Jim Lehrer as commentators. Although all of the Big Three TV Networks ran coverage of the hearings, PBS re-broadcast them on prime time. For seven months, nightly "gavel-to-gavel" broadcasts drew great public interest, and raised the profile of the fledgling PBS network.
In 1991, the Corporation for Public Broadcasting resumed funding for most PBS shows that debuted prior to 1977, with the exceptions of Washington Week in Review and Wall Street Week (CPB resumed funding of Washington Week in 1997).
In 1994, The Chronicle of Philanthropy released the results of the largest study on the popularity and credibility of charitable and non-profit organizations. PBS ranked as the 11th "most popular charity/non-profit in America" from over 100 charities researched in the study conducted by the industry publication, with 38.2% of Americans over the age of 12 choosing "love" and "like a lot" for PBS.
Since the mid-2000s, Roper Opinion Research polls commissioned by PBS have consistently placed the service as the most-trusted national institution in the United States. A 2016–2017 study by Nielsen Media Research found 80% of all US television households view the network's programs over the course of a year. However, PBS is not responsible for all programming carried on public television stations, a large proportion of which may come from its member stations—including WGBH-TV, WETA-TV, WNET, WTTW, WQED, WHYY-TV, Twin Cities PBS—American Public Television, and independent producers. This distinction regarding the origin of different programs on the service presents a frequent source of viewer confusion.
In December 2009, PBS signed up for the Nielsen ratings audience measurement reports, and began to be included in its primetime and daily "Television Index" reports, alongside the major commercial broadcast networks.
In May 2011,
|
https://en.wikipedia.org/wiki/PBS
|
A property, in some object-oriented programming languages, is a special sort of class member, intermediate in functionality between a field (or data member) and a method. The syntax for reading and writing of properties is like for fields, but property reads and writes are (usually) translated to 'getter' and 'setter' method calls. The field-like syntax is easier to read and write than many method calls, yet the interposition of method calls "under the hood" allows for data validation, active updating (e.g., of GUI elements), or implementation of what may be called "read-only fields".
== Support in languages ==
Programming languages that support properties include ActionScript 3, C#, D, Delphi/Free Pascal, eC, F#, Kotlin, JavaScript, Objective-C 2.0, Python, Scala, Swift, Lua, and Visual Basic.
Some object-oriented languages, such as Java and C++, do not support properties, requiring the programmer to define a pair of accessor and mutator methods instead.
Oberon-2 provides an alternative mechanism using object variable visibility flags.
Other languages designed for the Java Virtual Machine, such as Groovy, natively support properties.
While C++ does not have first class properties, they can be emulated with operator overloading.
Also note that some C++ compilers support first class properties as language extensions.
In Microsoft Visual Studio, GCC, and llvm/clang, the __declspec(property) creates properties similar to C#.
Borland C++ and Borland/CodeGear/Embarcadero C++Builder use the __property keyword.
In many object oriented languages properties are implemented as a pair of accessor/mutator methods, but accessed using the same syntax as for public fields. Omitting a method from the pair yields a read-only or an uncommon write-only property.
In some languages with no built-in support for properties, a similar construct can be implemented as a single method that either returns or changes the underlying data, depending on the context of its invocation. Such techniques are used e.g. in Perl.
Some languages (Ruby, Smalltalk) achieve property-like syntax using normal methods, sometimes with a limited amount of syntactic sugar.
== Syntax variants ==
Some languages follow well-established syntax conventions for formally specifying and utilizing properties and methods.
Among these conventions:
Dot notation
Bracket notation
=== Dot notation ===
The following example demonstrates dot notation in JavaScript.
=== Bracket notation ===
The following example demonstrates bracket notation in JavaScript.
== Example syntax ==
=== C# ===
Recent C# versions also allow "auto-implemented properties" where the backing field for the property is generated by the compiler during compilation. This means that the property must have a setter. However, it can be private.
=== C++ ===
C++ does not have first class properties, but there exist several ways to emulate properties to a limited degree. Two of which follow:
==== Using Standard C++ ====
Also see Stack Overflow for a more detailed example.
==== C++, Microsoft, GCC, LLVM/clang and C++Builder-specific ====
An example taken from the MSDN documentation page.
=== D ===
In D version 2, each property accessor or mutator must be marked with @property:
=== Delphi/Free Pascal ===
=== eC ===
=== F# ===
=== JavaScript ===
=== ActionScript 3.0 ===
=== Objective-C 2.0 ===
The above example could be used in an arbitrary method like this:
=== PHP ===
=== Python ===
Properties only work correctly for new-style classes (classes that have object as a superclass), and are only available in Python 2.2 and newer (see the relevant section of the tutorial Unifying types and classes in Python 2.2). Python 2.6 added a new syntax involving decorators for defining properties.
=== Ruby ===
Ruby also provides automatic getter/setter synthesizers defined as instance methods of Class.
=== Visual Basic ===
==== Visual Basic (.NET 2003–2010) ====
==== Visual Basic (only .NET 2010
|
https://en.wikipedia.org/wiki/Property_(programming)
|
The Apollo program, also known as Project Apollo, was the United States human spaceflight program led by NASA, which successfully landed the first humans on the Moon in 1969. Apollo followed Project Mercury that put the first Americans in space. It was conceived in 1960 as a three-person spacecraft during President Dwight D. Eisenhower's administration. Apollo was later dedicated to President John F. Kennedy's national goal for the 1960s of "landing a man on the Moon and returning him safely to the Earth" in an address to Congress on May 25, 1961. It was the third American human spaceflight program to fly, preceded by Project Gemini conceived in 1961 to extend spaceflight capability in support of Apollo.
Kennedy's goal was accomplished on the Apollo 11 mission when astronauts Neil Armstrong and Buzz Aldrin landed their Apollo Lunar Module (LM) on July 20, 1969, and walked on the lunar surface, while Michael Collins remained in lunar orbit in the command and service module (CSM), and all three landed safely on Earth in the Pacific Ocean on July 24. Five subsequent Apollo missions also landed astronauts on the Moon, the last, Apollo 17, in December 1972. In these six spaceflights, twelve people walked on the Moon.
Apollo ran from 1961 to 1972, with the first crewed flight in 1968. It encountered a major setback in 1967 when an Apollo 1 cabin fire killed the entire crew during a prelaunch test. After the first successful landing, sufficient flight hardware remained for nine follow-on landings with a plan for extended lunar geological and astrophysical exploration. Budget cuts forced the cancellation of three of these. Five of the remaining six missions achieved successful landings, but the Apollo 13 landing had to be aborted after an oxygen tank exploded en route to the Moon, crippling the CSM. The crew barely managed a safe return to Earth by using the lunar module as a "lifeboat" on the return journey. Apollo used the Saturn family of rockets as launch vehicles, which were also used for an Apollo Applications Program, which consisted of Skylab, a space station that supported three crewed missions in 1973–1974, and the Apollo–Soyuz Test Project, a joint United States-Soviet Union low Earth orbit mission in 1975.
Apollo set several major human spaceflight milestones. It stands alone in sending crewed missions beyond low Earth orbit. Apollo 8 was the first crewed spacecraft to orbit another celestial body, and Apollo 11 was the first crewed spacecraft to land humans on one.
Overall, the Apollo program returned 842 pounds (382 kg) of lunar rocks and soil to Earth, greatly contributing to the understanding of the Moon's composition and geological history. The program laid the foundation for NASA's subsequent human spaceflight capability and funded construction of its Johnson Space Center and Kennedy Space Center. Apollo also spurred advances in many areas of technology incidental to rocketry and human spaceflight, including avionics, telecommunications, and computers.
== Name ==
The program was named after Apollo, the Greek god of light, music, and the Sun, by NASA manager Abe Silverstein, who later said, "I was naming the spacecraft like I'd name my baby." Silverstein chose the name at home one evening, early in 1960, because he felt "Apollo riding his chariot across the Sun was appropriate to the grand scale of the proposed program".
The context of this was that the program focused at its beginning mainly on developing an advanced crewed spacecraft, the Apollo command and service module, succeeding the Mercury program. A lunar landing became the focus of the program only in 1961. Thereafter Project Gemini instead followed the Mercury program to test and study advanced crewed spaceflight technology.
== Background ==
=== Origin and spacecraft feasibility studies ===
The Apollo program was conceived during the Eisenhower administration in early 1960, as a follow-up to Project Mercury. While the Mercury capsule could support o
|
https://en.wikipedia.org/wiki/Apollo_program
|
In computer programming, assembly language (alternatively assembler language or symbolic machine code), often referred to simply as assembly and commonly abbreviated as ASM or asm, is any low-level programming language with a very strong correspondence between the instructions in the language and the architecture's machine code instructions. Assembly language usually has one statement per machine instruction (1:1), but constants, comments, assembler directives, symbolic labels of, e.g., memory locations, registers, and macros are generally also supported.
The first assembly code in which a language is used to represent machine code instructions is found in Kathleen and Andrew Donald Booth's 1947 work, Coding for A.R.C.. Assembly code is converted into executable machine code by a utility program referred to as an assembler. The term "assembler" is generally attributed to Wilkes, Wheeler and Gill in their 1951 book The Preparation of Programs for an Electronic Digital Computer, who, however, used the term to mean "a program that assembles another program consisting of several sections into a single program". The conversion process is referred to as assembly, as in assembling the source code. The computational step when an assembler is processing a program is called assembly time.
Because assembly depends on the machine code instructions, each assembly language is specific to a particular computer architecture.
Sometimes there is more than one assembler for the same architecture, and sometimes an assembler is specific to an operating system or to particular operating systems. Most assembly languages do not provide specific syntax for operating system calls, and most assembly languages can be used universally with any operating system, as the language provides access to all the real capabilities of the processor, upon which all system call mechanisms ultimately rest. In contrast to assembly languages, most high-level programming languages are generally portable across multiple architectures but require interpreting or compiling, much more complicated tasks than assembling.
In the first decades of computing, it was commonplace for both systems programming and application programming to take place entirely in assembly language. While still irreplaceable for some purposes, the majority of programming is now conducted in higher-level interpreted and compiled languages. In "No Silver Bullet", Fred Brooks summarised the effects of the switch away from assembly language programming: "Surely the most powerful stroke for software productivity, reliability, and simplicity has been the progressive use of high-level languages for programming. Most observers credit that development with at least a factor of five in productivity, and with concomitant gains in reliability, simplicity, and comprehensibility."
Today, it is typical to use small amounts of assembly language code within larger systems implemented in a higher-level language, for performance reasons or to interact directly with hardware in ways unsupported by the higher-level language. For instance, just under 2% of version 4.9 of the Linux kernel source code is written in assembly; more than 97% is written in C.
== Assembly language syntax ==
Assembly language uses a mnemonic to represent, e.g., each low-level machine instruction or opcode, each directive, typically also each architectural register, flag, etc. Some of the mnemonics may be built-in and some user-defined. Many operations require one or more operands in order to form a complete instruction. Most assemblers permit named constants, registers, and labels for program and memory locations, and can calculate expressions for operands. Thus, programmers are freed from tedious repetitive calculations and assembler programs are much more readable than machine code. Depending on the architecture, these elements may also be combined for specific instructions or addressing modes using offsets or other data as well as fixed ad
|
https://en.wikipedia.org/wiki/Assembly_language
|
In computer science, programming by demonstration (PbD) is an end-user development technique for teaching a computer or a robot new behaviors by demonstrating the task to transfer directly instead of programming it through machine commands.
The terms programming by example (PbE) and programming by demonstration (PbD) appeared in software development research as early as the mid 1980s to define a way to define a sequence of operations without having to learn a programming language. The usual distinction in literature between these terms is that in PbE the user gives a prototypical product of the computer execution, such as a row in the desired results of a query; while in PbD the user performs a sequence of actions that the computer must repeat, generalizing it to be used in different data sets.
These two terms were first undifferentiated, but PbE then tended to be mostly adopted by software development researchers while PbD tended to be adopted by robotics researchers. Today, PbE refers to an entirely different concept, supported by new programming languages that are similar to simulators. This framework can be contrasted with Bayesian program synthesis.
== Robot programming by demonstration ==
The PbD paradigm is first attractive to the robotics industry due to the costs involved in the development and maintenance of robot programs. In this field, the operator often has implicit knowledge on the task to achieve (he/she knows how to do it), but does not have usually the programming skills (or the time) required to reconfigure the robot. Demonstrating how to achieve the task through examples thus allows to learn the skill without explicitly programming each detail.
The first PbD strategies proposed in robotics were based on teach-in, guiding or play-back methods that consisted
basically in moving the robot (through a dedicated interface or manually) through a set of relevant configurations that the robot
should adopt sequentially (position, orientation, state of the gripper). The method was then progressively ameliorated by
focusing principally on the teleoperation control and by using different interfaces such as vision.
However, these PbD methods still used direct repetition, which was useful in industry only when conceiving an assembly line using exactly the same product components. To apply this concept to products with different variants or to apply the programs to new robots, the generalization issue became a crucial point. To address this issue, the first attempts at generalizing the skill
were mainly based on the help of the user through queries about the user's intentions. Then, different levels of abstractions were
proposed to resolve the generalization issue, basically dichotomized in learning methods at a symbolic level or at a trajectory level.
The development of humanoid robots naturally brought a growing interest in robot programming by demonstration. As a humanoid robot is supposed by its nature to adapt to new environments, not only the human appearance is important but the algorithms used for its control require flexibility and versatility. Due to the continuously changing environments and to the huge varieties of tasks that a robot is expected to perform, the robot requires the ability to continuously learn new skills and adapt the existing skills to new contexts.
Research in PbD also progressively departed from its original purely engineering perspective to adopt an interdisciplinary approach, taking insights from neuroscience and social sciences to emulate the process of imitation in humans and animals. With the increasing consideration of this body of work in robotics, the notion of Robot programming by demonstration (also known as RPD or RbD) was also progressively replaced by the more biological label of Learning by imitation.
=== Neurally-imprinted Stable Vector Fields (NiVF) ===
Neurally-imprinted Stable Vector Fields (NiVF) was introduced as a novel learning scheme during ESANN 2013 and show how t
|
https://en.wikipedia.org/wiki/Programming_by_demonstration
|
An application programming interface (API) is a connection between computers or between computer programs. It is a type of software interface, offering a service to other pieces of software. A document or standard that describes how to build such a connection or interface is called an API specification. A computer system that meets this standard is said to implement or expose an API. The term API may refer either to the specification or to the implementation.
In contrast to a user interface, which connects a computer to a person, an application programming interface connects computers or pieces of software to each other. It is not intended to be used directly by a person (the end user) other than a computer programmer who is incorporating it into software. An API is often made up of different parts which act as tools or services that are available to the programmer. A program or a programmer that uses one of these parts is said to call that portion of the API. The calls that make up the API are also known as subroutines, methods, requests, or endpoints. An API specification defines these calls, meaning that it explains how to use or implement them.
One purpose of APIs is to hide the internal details of how a system works, exposing only those parts a programmer will find useful and keeping them consistent even if the internal details later change. An API may be custom-built for a particular pair of systems, or it may be a shared standard allowing interoperability among many systems.
The term API is often used to refer to web APIs, which allow communication between computers that are joined by the internet. There are also APIs for programming languages, software libraries, computer operating systems, and computer hardware. APIs originated in the 1940s, though the term did not emerge until the 1960s and 70s.
== Purpose ==
An API opens a software system to interactions from the outside. It allows two software systems to communicate across a boundary — an interface — using mutually agreed-upon signals. In other words, an API connects software entities together. Unlike a user interface, an API is typically not visible to users. It is an "under the hood" portion of a software system, used for machine-to-machine communication.
A well-designed API exposes only objects or actions needed by software or software developers. It hides details that have no use. This abstraction simplifies programming.
Building software using APIs has been compared to using building-block toys, such as Lego bricks. Software services or software libraries are analogous to the bricks; they may be joined together via their APIs, composing a new software product. The process of joining is called integration.
As an example, consider a weather sensor that offers an API. When a certain message is transmitted to the sensor, it will detect the current weather conditions and reply with a weather report. The message that activates the sensor is an API call, and the weather report is an API response. A weather forecasting app might integrate with a number of weather sensor APIs, gathering weather data from throughout a geographical area.
An API is often compared to a contract. It represents an agreement between parties: a service provider who offers the API and the software developers who rely upon it. If the API remains stable, or if it changes only in predictable ways, developers' confidence in the API will increase. This may increase their use of the API.
== History of the term ==
The term API initially described an interface only for end-user-facing programs, known as application programs. This origin is still reflected in the name "application programming interface." Today, the term is broader, including also utility software and even hardware interfaces.
The idea of the API is much older than the term itself. British computer scientists Maurice Wilkes and David Wheeler worked on a modular software library in the 1940s for EDSAC, an early computer. The subrout
|
https://en.wikipedia.org/wiki/API
|
In computer science, function-level programming refers to one of the two contrasting programming paradigms identified by John Backus in his work on programs as mathematical objects, the other being value-level programming.
In his 1977 Turing Award lecture, Backus set forth what he considered to be the need to switch to a different philosophy in programming language design:
Programming languages appear to be in trouble. Each successive language incorporates, with a little cleaning up, all the features of its predecessors plus a few more. [...] Each new language claims new and fashionable features... but the plain fact is that few languages make programming sufficiently cheaper or more reliable to justify the cost of producing and learning to use them.
He designed FP to be the first programming language to specifically support the function-level programming style.
A function-level program is variable-free (cf. point-free programming), since program variables, which are essential in value-level definitions, are not needed in function-level programs.
== Introduction ==
In the function-level style of programming, a program is built directly from programs that are given at the outset, by combining them with program-forming operations or functionals. Thus, in contrast with the value-level approach that applies the given programs to values to form a succession of values culminating in the desired result value, the function-level approach applies program-forming operations to the given programs to form a succession of programs culminating in the desired result program.
As a result, the function-level approach to programming invites study of the space of programs under program-forming operations, looking to derive useful algebraic properties of these program-forming operations. The function-level approach offers the possibility of making the set of programs a mathematical space by emphasizing the algebraic properties of the program-forming operations over the space of programs.
Another potential advantage of the function-level view is the ability to use only strict functions and thereby have bottom-up semantics, which are the simplest kind of all. Yet another is the existence of function-level definitions that are not the lifted (that is, lifted from a lower value-level to a higher function-level) image of any existing value-level one: these (often terse) function-level definitions represent a more powerful style of programming not available at the value-level.
== Contrast to functional programming ==
When Backus studied and publicized his function-level style of programming, his message was mostly misunderstood as supporting the traditional functional programming style languages instead of his own FP and its successor FL.
Backus calls functional programming applicative programming; his function-level programming is a particular, constrained type.
A key distinction from functional languages is that Backus' language has the following hierarchy of types:
atoms
functions, which take atoms to atoms
Higher-order functions (which he calls "functional forms"), which take one or two functions to functions
...and the only way to generate new functions is to use one of the functional forms, which are fixed: you cannot build your own functional form (at least not within FP; you can within FFP (Formal FP)).
This restriction means that functions in FP are a module (generated by the built-in functions) over the algebra of functional forms, and are thus algebraically tractable. For instance, the general question of equality of two functions is equivalent to the halting problem, and is undecidable, but equality of two functions in FP is just equality in the algebra, and thus (Backus imagines) easier.
Even today, many users of lambda style languages often misinterpret Backus' function-level approach as a restrictive variant of the lambda style, which is a de facto value-level style. In fact, Backus would not have disagreed with the 'restrictive'
|
https://en.wikipedia.org/wiki/Function-level_programming
|
In computer programming, a naming convention is a set of rules for choosing the character sequence to be used for identifiers which denote variables, types, functions, and other entities in source code and documentation.
Reasons for using a naming convention (as opposed to allowing programmers to choose any character sequence) include the following:
To reduce the effort needed to read and understand source code;
To enable code reviews to focus on issues more important than syntax and naming standards.
To enable code quality review tools to focus their reporting mainly on significant issues other than syntax and style preferences.
The choice of naming conventions can be a controversial issue, with partisans of each holding theirs to be the best and others to be inferior. Colloquially, this is said to be a matter of dogma. Many companies have also established their own set of conventions.
== Potential benefits ==
Benefits of a naming convention can include the following:
to provide additional information (i.e., metadata) about the use to which an identifier is put;
to help formalize expectations and promote consistency within a development team;
to enable the use of automated refactoring or search and replace tools with minimal potential for error;
to enhance clarity in cases of potential ambiguity;
to enhance the aesthetic and professional appearance of work product (for example, by disallowing overly long names, comical or "cute" names, or abbreviations);
to help avoid "naming collisions" that might occur when the work product of different organizations is combined (see also: namespaces);
to provide meaningful data to be used in project handovers which require submission of program source code and all relevant documentation;
to provide better understanding in case of code reuse after a long interval of time.
== Challenges ==
The choice of naming conventions (and the extent to which they are enforced) is often a contentious issue, with partisans holding their viewpoint to be the best and others to be inferior. Moreover, even with known and well-defined naming conventions in place, some organizations may fail to consistently adhere to them, causing inconsistency and confusion. These challenges may be exacerbated if the naming convention rules are internally inconsistent, arbitrary, difficult to remember, or otherwise perceived as more burdensome than beneficial.
== Readability ==
Well-chosen identifiers make it significantly easier for developers and analysts to understand what the system is doing and how to fix or extend the source code to apply for new needs.
For example, although
is syntactically correct, its purpose is not evident. Contrast this with:
which implies the intent and meaning of the source code, at least to those familiar with the context of the statement.
Experiments suggest that identifier style affects recall and precision and that familiarity with a style speeds recall.
== Common elements ==
The exact rules of a naming convention depend on the context in which they are employed. Nevertheless, there are several common elements that influence most if not all naming conventions in common use today.
=== Length of identifiers ===
Fundamental elements of all naming conventions are the rules related to identifier length (i.e., the finite number of individual characters allowed in an identifier). Some rules dictate a fixed numerical bound, while others specify less precise heuristics or guidelines.
Identifier length rules are routinely contested in practice, and subject to much debate academically.
Some considerations:
shorter identifiers may be preferred as more expedient, because they are easier to type (although many IDEs and text-editors provide text-completion, which mitigates this)
extremely short identifiers (such as 'i' or 'j') are very difficult to uniquely distinguish using automated search and replace tools (although this is not an issue for regex-based tools)
longer identifiers may be p
|
https://en.wikipedia.org/wiki/Naming_convention_(programming)
|
Dryad was a research project at Microsoft Research for a general purpose runtime for execution of data parallel applications.
The research prototypes of the Dryad and DryadLINQ data-parallel processing frameworks are available in source form at GitHub.
== Overview ==
Microsoft made several preview releases of this technology available as add-ons to Windows HPC Server 2008 R2.
An application written for Dryad is modeled as a directed acyclic graph (DAG). The DAG defines the dataflow of the application, and the vertices of the graph defines the operations that are to be performed on the data. The "computational vertices" are written using sequential constructs, devoid of any concurrency or mutual exclusion semantics. The Dryad runtime parallelizes the dataflow graph by distributing the computational vertices across various execution engines (which can be multiple processor cores on the same computer or different physical computers connected by a network, as in a cluster). Scheduling of the computational vertices on the available hardware is handled by the Dryad runtime, without any explicit intervention by the developer of the application or administrator of the network. The flow of data between one computational vertex to another is implemented by using communication "channels" between the vertices, which in physical implementation is realized by TCP/IP streams, shared memory or temporary files. A stream is used at runtime to transport a finite number of structured Items.
Dryad defines a domain-specific language, which is implemented via a C++ library, that is used to create and model a Dryad execution graph. Computational vertices are written using standard C++ constructs. To make them accessible to the Dryad runtime, they must be encapsulated in a class that inherits from the GraphNode base class. The graph is defined by adding edges; edges are added by using a composition operator (defined by Dryad) that connects two graphs (or two nodes of a graph) with an edge. Managed code wrappers for the Dryad API can also be written.
There exist several high-level language compilers which use Dryad as a runtime; examples include Scope (Structured Computations Optimized for Parallel Execution) and DryadLINQ.
In October 2011, Microsoft discontinued active development on Dryad, shifting focus to the Apache Hadoop framework.
== References ==
== Further reading ==
"Dryad: Distributed Data-Parallel Programs from Sequential Building Blocks" (PDF). Microsoft Research. Retrieved 2007-12-04.
"SCOPE: Easy and Efficient Parallel Processing of Massive Data Sets" (PDF). Microsoft Research. Retrieved 2009-01-21.
== External links ==
Dryad: Programming the Data Center Archived 2007-09-12 at the Wayback Machine
Dryad Home
Video of Michael Isard explaining Dryad at Google
|
https://en.wikipedia.org/wiki/Dryad_(programming)
|
ESPN (an initialism of their original name, which was the Entertainment and Sports Programming Network) is an American international basic cable sports channel owned by the Walt Disney Company (80% and operational control) and Hearst Communications (20%) through the joint venture ESPN Inc. The company was founded in 1979 by Bill Rasmussen, Scott Rasmussen and Ed Eagan.
ESPN broadcasts primarily from studio facilities located in Bristol, Connecticut. The network also operates offices and auxiliary studios in Miami, Orlando, New York City, Las Vegas, Seattle, Charlotte, Washington, D.C., and Los Angeles. James Pitaro has been chairman since March 5, 2018, following the resignation of John Skipper on December 18, 2017.
As of December 2023, ESPN is available to approximately 70 million pay television households in the United States—down from its 2011 peak of 100 million households. It operates regional channels in Africa, Australia, Latin America, and the Netherlands. In Canada, it owns a 20% interest in The Sports Network (TSN) and its five sister networks. Despite the network's success, criticism of ESPN includes accusations of biased coverage.
== History ==
=== Background and Launch ===
Bill Rasmussen came up with the concept of ESPN in May 1978, after he was fired from his job with the World Hockey Association's New England Whalers. Rasmussen and his ESPN co-founder Ed Eagan, joined by Rasmussen's son Scott (who had also been let go by the Whalers), first rented office space in Plainville, Connecticut. However, the plan to base ESPN there was put on hold because of a local ordinance prohibiting buildings from bearing rooftop satellite dishes. Available land to build their own facility on was quickly found in Bristol, Connecticut (where the channel remains headquartered to this day), with funding to buy the property provided by Getty Oil, which purchased 85% of the company from Bill Rasmussen on February 22, 1979, in an attempt to diversify the company's holdings. This helped the credibility of the fledgling company; however, there were still many doubters about the viability of their sports channel concept. Another event that helped build ESPN's credibility was securing an advertising agreement with Anheuser-Busch in the spring of 1979; the company invested $1 million to be the "exclusive beer advertised on the network".
ESPN launched on September 7, 1979, beginning with the first telecast of what would become the channel's flagship program, SportsCenter. Taped in front of a small live audience inside the Bristol studios, it was broadcast to 1.4 million cable subscribers throughout the United States. One month after launch, Chris Berman joined the network; he would continue to be an on-air fixture for decades.
=== 1980s to 2000s ===
ESPN's next big step forward came when the channel acquired the rights to broadcast coverage of the early rounds of the NCAA Division I men's basketball tournament. It first aired its games in March 1980, helping bring attention to what is today known as "March Madness". The channel's tournament coverage also launched the broadcasting career of Dick Vitale, who at the time he joined ESPN had just been fired as head coach of the Detroit Pistons.
In April of that year ESPN began televising the NFL draft, bringing it also to a mass audience and over time creating a television "event". That same month the network began broadcasting Top Rank Boxing on ESPN, marking the beginning of its involvement with televised professional boxing. The show lasted 16 years, and ESPN has since shown boxing live intermittently with other shows including ESPN Friday Night Fights and others. For a period during the 1980s, the network had boxing tournaments, crowning champions in different boxing weight divisions as "ESPN champions".
The next major stepping stone for ESPN came throughout a couple of months in 1984. During this period, the American Broadcasting Company (ABC) purchased 100% of ESPN from the Rasmussen
|
https://en.wikipedia.org/wiki/ESPN
|
This is a list of most-watched Netflix original programming in total hours viewed, in the first 28 days of being uploaded to Netflix. These statistics are released by Netflix based on its proprietary engagement metrics.
== Series ==
Television shows on Netflix with over 200 million views in their first 28 days.
== Films ==
Films on Netflix with over 100 million views in their first 28 days.
== References ==
== External links ==
Official website
|
https://en.wikipedia.org/wiki/List_of_most-watched_Netflix_original_programming
|
Snippet is a programming term for a small region of re-usable source code, machine code, or text. Ordinarily, these are formally defined operative units to incorporate into larger programming modules. Snippet management is a feature of some text editors, program source code editors, IDEs, and related software. It allows the user to avoid repetitive typing in the course of routine edit operations.
== Definition ==
In programming practice, "snippet" refers narrowly to a portion of source code that is literally included by an editor program into a file, and is a form of copy and paste programming. This concrete inclusion is in contrast to abstraction methods, such as functions or macros, which are abstraction within the language. Snippets are thus primarily used when these abstractions are not available or not desired, such as in languages that lack abstraction, or for clarity and absence of overhead.
Snippets are similar to having static preprocessing included in the editor, and do not require support by a compiler. On the flip side, this means that snippets cannot be invariably modified after the fact, and thus is vulnerable to all of the problems of copy and paste programming. For this reason snippets are primarily used for simple sections of code (with little logic), or for boilerplate, such as copyright notices, function prototypes, common control structures, or standard library imports.
== Overview ==
Snippet management is a text editor feature popular among software developers or others who routinely require content from a catalogue of repeatedly entered text (such as with source code or boilerplate). Often this feature is justified because the content varies only slightly (or not at all) each time it is entered.
=== Snippets in text editors ===
Text editors that include this feature ordinarily provide a mechanism to manage the catalogue, and separate "snippets" in the same manner that the text editor and operating system allow management of separate files. These basic management abilities include operations such as viewing, adding, editing, deleting, sorting, filtering, grouping, renaming, and storing snippets in a repository, catalogue, or database. Some editors provide a macro ability to snippets allowing function prototypes and variable control structures to be generated based on a standard template.
=== Snippets in IDEs ===
Some programmer's applications such as Eclipse, NetBeans, and Microsoft's Visual Studio (uses TextMate-inspired snippets underhood) and other IDEs include built-in parts of structure for ease of coding.
Other applications such as Macromedia Dreamweaver make use of these code snippets as well for Web development.
=== Snippets in JIT compilers ===
Just-in-time (JIT) compilers can "splice together" pre-compiled sections of code as longer object code/machine code segments. This reduces interpret time significantly and simultaneously speeds execution.
=== Snippets in shells ===
Snippets may be used inside commandline interfaces like bash, zsh (GNU Linux/Unix-like) or powershell (MS Windows). Features like completion and placeholders substitution may or may not be supported.
== Example ==
Consider the process of swapping the values of two variables, x and y. Assuming weak typing and not being concerned about name collision, this is represented by the code:
temp = x
x = y
y = temp
When the snippet is inserted, the programmer is prompted for the values of the two parameters. Assuming they are type foo and bar, which are the actual names of the variables they wish to swap, this will yield the code:
temp = foo
foo = bar
bar = temp
If the snippet is subsequently changed, say to use __temp instead of temp, it will not change the code that has already been inserted, but will be used in subsequent insertions of the snippet.
A snippet for this might be represented as:
temp = $1
$1 = $2
$2 = temp
== Conventions ==
In addition to the basic management abilities described previously, snippet mana
|
https://en.wikipedia.org/wiki/Snippet_(programming)
|
In software systems, encapsulation refers to the bundling of data with the mechanisms or methods that operate on the data. It may also refer to the limiting of direct access to some of that data, such as an object's components. Essentially, encapsulation prevents external code from being concerned with the internal workings of an object.
Encapsulation allows developers to present a consistent interface that is independent of its internal implementation. As one example, encapsulation can be used to hide the values or state of a structured data object inside a class. This prevents clients from directly accessing this information in a way that could expose hidden implementation details or violate state invariance maintained by the methods.
Encapsulation also encourages programmers to put all the code that is concerned with a certain set of data in the same class, which organizes it for easy comprehension by other programmers. Encapsulation is a technique that encourages decoupling.
All object-oriented programming (OOP) systems support encapsulation, but encapsulation is not unique to OOP. Implementations of abstract data types, modules, and libraries also offer encapsulation. The similarity has been explained by programming language theorists in terms of existential types.
== Meaning ==
In object-oriented programming languages, and other related fields, encapsulation refers to one of two related but distinct notions, and sometimes to the combination thereof:
A language mechanism for restricting direct access to some of the object's components.
A language construct that facilitates the bundling of data with the methods (or other functions) operating on those data.
Some programming language researchers and academics use the first meaning alone or in combination with the second as a distinguishing feature of object-oriented programming, while some programming languages that provide lexical closures view encapsulation as a feature of the language orthogonal to object orientation.
The second definition reflects that in many object-oriented languages, and other related fields, the components are not hidden automatically and this can be overridden. Thus, information hiding is defined as a separate notion by those who prefer the second definition.
The features of encapsulation are supported using classes in most object-oriented languages, although other alternatives also exist.
Encapsulation may also refer to containing a repetitive or complex process in a single unit to be invoked. Object-oriented programming facilitate this at both the method and class levels. This definition is also applicable to procedural programming.
=== Encapsulation and inheritance ===
The authors of Design Patterns discuss the tension between inheritance and encapsulation at length and state that in their experience, designers overuse inheritance. They claim that inheritance often breaks encapsulation, given that inheritance exposes a subclass to the details of its parent's implementation. As described by the yo-yo problem, overuse of inheritance and therefore encapsulation, can become too complicated and hard to debug.
== Information hiding ==
Under the definition that encapsulation "can be used to hide data members and member functions", the internal representation of an object is generally hidden outside of the object's definition. Typically, only the object's own methods can directly inspect or manipulate its fields. Hiding the internals of the object protects its integrity by preventing users from setting the internal data of the component into an invalid or inconsistent state. A supposed benefit of encapsulation is that it can reduce system complexity, and thus increase robustness, by allowing the developer to limit the interdependencies between software components.
Some languages like Smalltalk and Ruby only allow access via object methods, but most others (e.g., C++, C#, Delphi or Java) offer the programmer some control over what is hidden, t
|
https://en.wikipedia.org/wiki/Encapsulation_(computer_programming)
|
Mesa is a programming language developed in the mid 1970s at the Xerox Palo Alto Research Center in Palo Alto, California, United States. The language name was a pun based upon the programming language catchphrases of the time, because Mesa is a "high level" programming language.
Mesa is an ALGOL-like language with strong support for modular programming. Every library module has at least two source files: a definitions file specifying the library's interface plus one or more program files specifying the implementation of the procedures in the interface. To use a library, a program or higher-level library must "import" the definitions. The Mesa compiler type-checks all uses of imported entities; this combination of separate compilation with type-checking was unusual at the time.
Mesa introduced several other innovations in language design and implementation, notably in the handling of software exceptions, thread synchronization, and incremental compilation.
Mesa was developed on the Xerox Alto, one of the first personal computers with a graphical user interface, however, most of the Alto's system software was written in BCPL. Mesa was the system programming language of the later Xerox Star workstations, and for the GlobalView desktop environment. Xerox PARC later developed Cedar, which was a superset of Mesa.
Mesa and Cedar had a major influence on the design of other important languages, such as Modula-2 and Java, and was an important vehicle for the development and dissemination of the fundamentals of GUIs, networked environments, and the other advances Xerox contributed to the field of computer science.
== History ==
Mesa was originally designed in the Computer Systems Laboratory (CSL), a branch of the Xerox Palo Alto Research Center, for the Alto, an experimental micro-coded workstation. Initially, its spread was confined to PARC and a few universities to which Xerox had donated some Altos.
Mesa was later adopted as the systems programming language for Xerox's commercial workstations such as the Xerox 8010 (Xerox Star, Dandelion) and Xerox 6085 (Daybreak), in particular for the Pilot operating system.
A secondary development environment, called the Xerox Development Environment (XDE) allowed developers to debug both the operating system Pilot as well as ViewPoint GUI applications using a world swap mechanism. This allowed the entire "state" of the world to be swapped out, and allowed low-level system crashes which paralyzed the whole system to be debugged. This technique did not scale very well to large application images (several megabytes), and so the Pilot/Mesa world in later releases moved away from the world swap view when the micro-coded machines were phased out in favor of SPARC workstations and Intel PCs running a Mesa PrincOps emulator for the basic hardware instruction set.
Mesa was compiled into a stack-machine language, purportedly with the highest code density ever achieved (roughly 4 bytes per high-level language statement). This was touted in a 1981 paper where implementors from the Xerox Systems Development Department (then, the development arm of PARC), tuned up the instruction set and published a paper on the resultant code density.
Mesa was taught via the Mesa Programming Course that took people through the wide range of technology Xerox had available at the time and ended with the programmer writing a "hack", a workable program designed to be useful. An actual example of such a hack is the BWSMagnifier, which was written in 1988 and allowed people to magnify sections of the workstation screen as defined by a resizable window and a changeable magnification factor. Trained Mesa programmers from Xerox were well versed in the fundamental of GUIs, networking, exceptions, and multi-threaded programming, almost a decade before they became standard tools of the trade.
Within Xerox, Mesa was eventually superseded by the Cedar programming language. Many Mesa programmers and developers left Xerox in 1985; som
|
https://en.wikipedia.org/wiki/Mesa_(programming_language)
|
This is a list of television programs broadcast by Nickelodeon in the United States. The channel was first tested on December 1, 1977, as an experimental local channel in Columbus, Ohio. On April 1, 1979, the channel expanded into a national network named Nickelodeon.
The first program broadcast on Nickelodeon was Pinwheel, a preschool series created by Dr. Vivian Horner, who also conceived the idea for the channel itself. At its launch, Nickelodeon was commercial-free and mainly featured educational shows. By 1984, the channel began accepting traditional commercials and introduced more entertainment-focused programming. In January 1988, the network launched a weekday morning block for preschoolers called Nick Jr., which carried Pinwheel and other educational series. Around the same time, Nickelodeon began investing in original animated shows, which premiered in 1991 under the "Nicktoons" branding. Since then, the channel has consistently aired a mix of original live-action and animated titles.
== Current programming ==
=== Original programming ===
==== Animated ====
==== Programming from Paramount+ ====
==== Live-action ====
===== Comedy =====
===== News and sports =====
==== Preschool series ====
==== Programming from Paramount+ ====
==== Specials ====
==== Educational series ====
=== Acquired programming ===
==== Animated ====
==== Preschool series ====
== Upcoming programming ==
=== Original programming ===
==== Animated ====
==== Live-action ====
===== Comedy =====
==== Preschool series ====
=== Acquired programming ===
==== Preschool series ====
== Former programming ==
=== Original programming ===
==== Animated ====
==== Live-action ====
===== Comedy =====
===== Drama =====
===== Game shows =====
===== Variety programs =====
==== Programming from Paramount+ ====
==== Preschool ====
===== Animated preschool series =====
===== Live-action preschool series =====
==== Programming from Noggin ====
==== Miniseries/other ====
=== Former acquired programming ===
==== Former acquired animated series ====
==== Former acquired live-action comedy series ====
==== Former acquired action series ====
==== Former acquired reality series ====
American Ninja Warrior (2019)
==== Former acquired drama series ====
==== Former acquired variety series ====
==== Former acquired preschool series ====
== Programming blocks ==
=== Seasonal programming blocks ===
== See also ==
Nick on CBS
List of programs broadcast by Nick at Nite
List of programs broadcast by Nicktoons
List of programs broadcast by Noggin
List of programs broadcast by TeenNick
List of programs broadcast by the Nick Jr. Channel
List of Nickelodeon Animation Studio productions
List of Nickelodeon original films
List of Nickelodeon short films
== Notes ==
== References ==
|
https://en.wikipedia.org/wiki/List_of_programs_broadcast_by_Nickelodeon
|
A geometric program (GP) is an optimization problem of the form
minimize
f
0
(
x
)
subject to
f
i
(
x
)
≤
1
,
i
=
1
,
…
,
m
g
i
(
x
)
=
1
,
i
=
1
,
…
,
p
,
{\displaystyle {\begin{array}{ll}{\mbox{minimize}}&f_{0}(x)\\{\mbox{subject to}}&f_{i}(x)\leq 1,\quad i=1,\ldots ,m\\&g_{i}(x)=1,\quad i=1,\ldots ,p,\end{array}}}
where
f
0
,
…
,
f
m
{\displaystyle f_{0},\dots ,f_{m}}
are posynomials and
g
1
,
…
,
g
p
{\displaystyle g_{1},\dots ,g_{p}}
are monomials. In the context of geometric programming (unlike standard mathematics), a monomial is a function from
R
+
+
n
{\displaystyle \mathbb {R} _{++}^{n}}
to
R
{\displaystyle \mathbb {R} }
defined as
x
↦
c
x
1
a
1
x
2
a
2
⋯
x
n
a
n
{\displaystyle x\mapsto cx_{1}^{a_{1}}x_{2}^{a_{2}}\cdots x_{n}^{a_{n}}}
where
c
>
0
{\displaystyle c>0\ }
and
a
i
∈
R
{\displaystyle a_{i}\in \mathbb {R} }
. A posynomial is any sum of monomials.
Geometric programming is
closely related to convex optimization: any GP can be made convex by means of a change of variables. GPs have numerous applications, including component sizing in IC design, aircraft design, maximum likelihood estimation for logistic regression in statistics, and parameter tuning of positive linear systems in control theory.
== Convex form ==
Geometric programs a
|
https://en.wikipedia.org/wiki/Geometric_programming
|
The International Conference on Functional Programming (ICFP) is an annual academic conference in the field of computer science sponsored by the ACM SIGPLAN, in association with IFIP Working Group 2.8 (Functional Programming). The conference focuses on functional programming and related areas of programming languages, logic, compilers and software development.
The ICFP was first held in 1996, replacing two biennial conferences: the Functional Programming and Computer Architecture (FPCA) and LISP and Functional Programming (LFP). The conference location alternates between Europe and North America, with occasional appearances in other continents. The conference usually lasts 3 days, surrounded by co-located workshops devoted to particular functional languages or application areas.
The ICFP has also held an open annual programming contest since 1998, called the ICFP Programming Contest.
== History ==
2012: 17th ACM SIGPLAN International Conference on Functional Programming in Copenhagen, Denmark (General Chair: Peter Thiemann, University of Freiburg; Program Chair: Robby Findler, Northwestern University)
== See also ==
Related conferences
FSCD : International Conference on Formal Structures for Computation and Deduction
FLOPS: International Symposium on Functional and Logic Programming
IFL: International Symposia on Implementation and Application of Functional Languages
ISMM: International Symposium on Memory Management
MPC: International Conference on Mathematics of Program Construction
PLDI: Programming Language Design and Implementation
POPL: Principles of Programming Languages
PPDP: International Conference on Principles and Practice of Declarative Programming
TFP: Symposium on Trends in Functional Programming
TLCA: International Conference on Typed Lambda Calculi and Applications
TLDI: International Workshop on Types in Language Design and Implementation
SAS: International Static Analysis Symposium
Related journals
Journal of Functional Programming
Journal of Functional and Logic Programming
Higher-Order and Symbolic Computation
ACM Transactions on Programming Languages and Systems
== References ==
== External links ==
ICFP main site
ICFP 2023 conference
ICFP Programming Contest
|
https://en.wikipedia.org/wiki/International_Conference_on_Functional_Programming
|
In computer science, automatic programming is a type of computer programming in which some mechanism generates a computer program, to allow human programmers to write the code at a higher abstraction level.
There has been little agreement on the precise definition of automatic programming, mostly because its meaning has changed over time. David Parnas, tracing the history of "automatic programming" in published research, noted that in the 1940s it described automation of the manual process of punching paper tape. Later it referred to translation of high-level programming languages like Fortran and ALGOL. In fact, one of the earliest programs identifiable as a compiler was called Autocode. Parnas concluded that "automatic programming has always been a euphemism for programming in a higher-level language than was then available to the programmer."
Program synthesis is one type of automatic programming where a procedure is created from scratch, based on mathematical requirements.
== Origin ==
Mildred Koss, an early UNIVAC programmer, explains: "Writing machine code involved several tedious steps—breaking down a process into discrete instructions, assigning specific memory locations to all the commands, and managing the I/O buffers. After following these steps to implement mathematical routines, a sub-routine library, and sorting programs, our task was to look at the larger programming process. We needed to understand how we might reuse tested code and have the machine help in programming. As we programmed, we examined the process and tried to think of ways to abstract these steps to incorporate them into higher-level language. This led to the development of interpreters, assemblers, compilers, and generators—programs designed to operate on or produce other programs, that is, automatic programming."
== Generative programming ==
Generative programming and the related term meta-programming are concepts whereby programs can be written "to manufacture software components in an automated way" just as automation has improved "production of traditional commodities such as garments, automobiles, chemicals, and electronics."
The goal is to improve programmer productivity. It is often related to code-reuse topics such as component-based software engineering.
== Source-code generation ==
Source-code generation is the process of generating source code based on a description of the problem or an ontological model such as a template and is accomplished with a programming tool such as a template processor or an integrated development environment (IDE). These tools allow the generation of source code through any of various means.
Modern programming languages are well supported by tools like Json4Swift (Swift) and Json2Kotlin (Kotlin).
Programs that could generate COBOL code include:
the DYL250/DYL260/DYL270/DYL280 series
Business Controls Corporation's SB-5
Peat Marwick Mitchell's PMM2170 application-program-generator package
These application generators supported COBOL inserts and overrides.
A macro processor, such as the C preprocessor, which replaces patterns in source code according to relatively simple rules, is a simple form of source-code generator. Source-to-source code generation tools also exist.
Large language models such as ChatGPT are capable of generating a program's source code from a description of the program given in a natural language.
Many relational database systems provide a function that will export the content of the database as SQL data definition queries, which may then be executed to re-import the tables and their data, or migrate them to another RDBMS.
== Low-code applications ==
A low-code development platform (LCDP) is software that provides an environment programmers use to create application software through graphical user interfaces and configuration instead of traditional computer programming.
== See also ==
Automatic bug fixing
Automated machine learning
Comparison of code generation tools
Feature-o
|
https://en.wikipedia.org/wiki/Automatic_programming
|
C++ (, pronounced "C plus plus" and sometimes abbreviated as CPP or CXX) is a high-level, general-purpose programming language created by Danish computer scientist Bjarne Stroustrup. First released in 1985 as an extension of the C programming language, adding object-oriented (OOP) features, it has since expanded significantly over time adding more OOP and other features; as of 1997/C++98 standardization, C++ has added functional features, in addition to facilities for low-level memory manipulation for systems like microcomputers or to make operating systems like Linux or Windows, and even later came features like generic (template) programming. C++ is usually implemented as a compiled language, and many vendors provide C++ compilers, including the Free Software Foundation, LLVM, Microsoft, Intel, Embarcadero, Oracle, and IBM.
C++ was designed with systems programming and embedded, resource-constrained software and large systems in mind, with performance, efficiency, and flexibility of use as its design highlights. C++ has also been found useful in many other contexts, with key strengths being software infrastructure and resource-constrained applications, including desktop applications, video games, servers (e.g., e-commerce, web search, or databases), and performance-critical applications (e.g., telephone switches or space probes).
C++ is standardized by the International Organization for Standardization (ISO), with the latest standard version ratified and published by ISO in October 2024 as ISO/IEC 14882:2024 (informally known as C++23). The C++ programming language was initially standardized in 1998 as ISO/IEC 14882:1998, which was then amended by the C++03, C++11, C++14, C++17, and C++20 standards. The current C++23 standard supersedes these with new features and an enlarged standard library. Before the initial standardization in 1998, C++ was developed by Stroustrup at Bell Labs since 1979 as an extension of the C language; he wanted an efficient and flexible language similar to C that also provided high-level features for program organization. Since 2012, C++ has been on a three-year release schedule with C++26 as the next planned standard.
Despite its widespread adoption, some notable programmers have criticized the C++ language, including Linus Torvalds, Richard Stallman, Joshua Bloch, Ken Thompson, and Donald Knuth. This is largely due to its manual memory management, which makes it vulnerable to buffer overflow bugs, which represent a security risk.
== History ==
In 1979, Bjarne Stroustrup, a Danish computer scientist, began work on "C with Classes", the predecessor to C++. The motivation for creating a new language originated from Stroustrup's experience in programming for his PhD thesis. Stroustrup found that Simula had features that were very helpful for large software development, but the language was too slow for practical use, while BCPL was fast but too low-level to be suitable for large software development. When Stroustrup started working in AT&T Bell Labs, he had the problem of analyzing the UNIX kernel with respect to distributed computing. Remembering his PhD experience, Stroustrup set out to enhance the C language with Simula-like features. C was chosen because it was general-purpose, fast, portable, and widely used. In addition to C and Simula's influences, other languages influenced this new language, including ALGOL 68, Ada, CLU, and ML.
Initially, Stroustrup's "C with Classes" added features to the C compiler, Cpre, including classes, derived classes, strong typing, inlining, and default arguments.
In 1982, Stroustrup started to develop a successor to C with Classes, which he named "C++" (++ being the increment operator in C) after going through several other names. New features were added, including virtual functions, function name and operator overloading, references, constants, type-safe free-store memory allocation (new/delete), improved type checking, and BCPL-style single-line comments with
|
https://en.wikipedia.org/wiki/C%2B%2B
|
Programming productivity (also called software productivity or development productivity) describes the degree of the ability of individual programmers or development teams to build and evolve software systems. Productivity traditionally refers to the ratio between the quantity of software produced and the cost spent for it. Here the delicacy lies in finding a reasonable way to define software quantity.
== Terminology ==
Productivity is an important topic investigated in disciplines as various as manufacturing, organizational psychology, industrial engineering, strategic management, finance, accounting, marketing and economics. Levels of analysis include the individual, the group, divisional, organizational and national levels. Due to this diversity, there is no clear-cut definition of productivity and its influencing factors, although research has been conducted for more than a century. Like in software engineering, this lack of common agreement on what actually constitutes productivity, is perceived as a major obstacle for a substantiated discussion of productivity. The following definitions describe the best consensus on the terminology.
=== Productivity ===
While there is no commonly agreed on definition of productivity, there appears to be an agreement that productivity describes the ratio between output and input:
Productivity = Output / Input
However, across the various disciplines different notions and, particularly, different measurement units for input and output can be found. The manufacturing industry typically uses a straightforward relation between the number of units produced and the number of units consumed. Non-manufacturing industries usually use man-hours or similar units to enable comparison between outputs and inputs.
One basic agreement is that the meaning of productivity and the means for measuring it vary depending on what context is under evaluation. In a manufacturing company the possible contexts are:
the individual machine or manufacturing system;
the manufacturing function, for example assembly;
the manufacturing process for a single product or group of related products;
the factory; and
the company's entire factory system
As long classical production processes are considered a straightforward metric of productivity is simple: how many units of a product of specified quality is produced by which costs. For intellectual work, productivity is much trickier. How do we measure the productivity of authors, scientists, or engineers? Due to the rising importance of knowledge work (as opposed to manual work), many researchers tried to develop productivity measurement means that can be applied in a non-manufacturing context. It is commonly agreed that the nature of knowledge work fundamentally differs from manual work and, hence, factors besides the simple output/input ratio need to be taken into account, e.g. quality, timeliness, autonomy, project success, customer satisfaction and innovation. However, the research communities in neither discipline have been able to establish broadly applicable and accepted means for productivity measurement yet. The same holds for more specific area of programming productivity.
=== Profitability ===
Profitability and performance are closely linked and are, in fact, often confused. However, as profitability is usually defined as the ratio between revenue and cost
Profitability = Revenue / Cost
It has a wider scope than performance, i.e. the number of factors that influence profitability is greater than the number of factors than influence productivity. Particularly, profitability can change without any change to the productivity, e.g. due to external conditions like cost or price inflation. Besides that, the interdependency between productivity and profitability is usually delayed, i.e. gains in productivity are rarely reflected in immediate profitability gains are more likely realized on the long-term.
=== Performance ===
The term performance is even broader than
|
https://en.wikipedia.org/wiki/Programming_productivity
|
Minification (also minimisation or minimization) is the process of removing all unnecessary characters from the source code of interpreted programming languages or markup languages without changing its functionality. These unnecessary characters usually include whitespace characters, new line characters, comments, and sometimes block delimiters, which are used to add readability to the code but are not required for it to execute. Minification reduces the size of the source code, making its transmission over a network (e.g. the Internet) more efficient. In programmer culture, aiming at extremely minified source code is the purpose of recreational code golf competitions and a part of the demoscene.
Minification can be distinguished from the more general concept of data compression in that the minified source can be interpreted immediately without the need for a decompression step: the same interpreter can work with both the original as well as with the minified source.
The goals of minification are not the same as the goals of obfuscation; the former is often intended to be reversed using a pretty-printer or unminifier. However, to achieve its goals, minification sometimes uses techniques also used by obfuscation; for example, shortening variable names and refactoring the source code. When minification uses such techniques, the pretty-printer or unminifier can only fully reverse the minification process if it is supplied details of the transformations done by such techniques. If not supplied those details, the reversed source code will contain different variable names and control flow, even though it will have the same functionality as the original source code.
== Example ==
For example, the JavaScript code
is equivalent to but longer than
== History ==
In 2001 Douglas Crockford introduced JSMin, which removed comments and whitespace from JavaScript code. It was followed by YUI Compressor in 2007. In 2009, Google opened up its Closure toolkit, including Closure Compiler which contained a source mapping feature together with a Firefox extension called Closure Inspector. In 2010, Mihai Bazon introduced UglifyJS, which was superseded by UglifyJS2 in 2012; the rewrite was to allow for source map support. From 2017, Alex Lam took over maintenance and development of UglifyJS2, replacing it with UglifyJS3 which unified the CLI with the API. In 2018, Terser has been forked from uglify-es and has gained momentum since; in 2020 it outstripped UglifyJS when measured in daily downloads.
== Source mapping ==
A source map is a file format that allows software tools for JavaScript to display different code to a user than the code actually executed by the computer. For example, to aid in debugging of minified code, by "mapping" this code to the original unminified source code instead.
The original format was created by Joseph Schorr as part of the Closure Inspector minification project. Version 2 and 3 of the format reduced the size of the map files considerably.
== Types ==
=== Tools ===
Visual Studio Code comes with minification support for several languages. It can readily browse the Visual Studio Marketplace to download and install additional minifiers.
JavaScript optimizers can minify and generate source maps. In addition certain online tools can compress CSS files.
=== Web development ===
Components and libraries for Web applications and websites have been developed to optimize file requests and reduce page load times by shrinking the size of various files.
JavaScript and Cascading Style Sheets (CSS) resources may be minified, preserving their behavior while considerably reducing their file size. Libraries available online are capable of minification and optimization to varying degrees. Some libraries also merge multiple script files into a single file for client download. JavaScript source maps can make code readable and debuggable even after it has been combined and minified.
== References ==
|
https://en.wikipedia.org/wiki/Minification_(programming)
|
Verse is a static typed object-oriented programming language created by Epic Games. It was released alongside UEFN in March 2023 and was authored by a team of well-known programmers led by Simon Peyton Jones, and Epic Games CEO Tim Sweeney. Verse is designed to interact with Fortnite Creative's existing devices system. As of June 2024, UEFN remains the only way to interpret, parse, compile or run Verse code; plans to implement the language into the release of Unreal Engine 6 have been discussed.
== Features ==
=== Modules and importing ===
Verse supports modular programming, allowing developers to import specific modules required for their scripts. Commonly used modules include the API digests that are generated every time a project containing verse is opened. There is an API digest to access and interact with Fortnite objects, Verse objects, and Unreal Engine objects. Developers can also create their own modules and import them into scripts if needed.
=== Classes and objects ===
Verse employs a class-based object-oriented programming model. Developers can define classes to represent various game entities and behaviors.
For example:
hello_world_device := class(creative_device):
OnBegin<override>()<suspends>:void=
Print("Hello, world!")
Print("2 + 2 = {2 + 2}")
The above code defines a new class inheriting from `creative_device` and prints the traditional "Hello, world" message. All classes inherited from a `creative_device' can be placed into the engine's spatial environment when compiled. The `creative_device` class is necessary to interact with the pre-existing Fortnite Creative toolset.
=== Functions and methods ===
Verse allows defining functions within classes. These can perform various operations, such as mathematical calculations, game logic, and more. The example below is a method to determine if a character is looking at a specific location.
IsLookingAtLocation(Character:fort_character, LocationToCheck: vector3, Threshold: float):logic
=== Event handling ===
The language supports event-driven programming, where events like EliminatedEvent and PlayerAddedEvent can trigger specified functions. Events can also be subscribed to and listened for.
=== Mathematical and spatial operations ===
Verse supports various mathematical functions necessary for game development, such as calculating magnitudes, normalizing vectors, and converting rotations to direction vectors. The spatial math module provides classes and functions for vector and rotational math, essential for game development tasks like positioning and movement.Cos, Normalize, Distance , ArcTan, and Lerp are a few of the functions are available for mathematical operations.
==== Lambda calculus ====
Verse code shares several similarities with lambda calculus, particularly in how it handles functions and data. In lambda calculus, functions are first-class citizens, meaning they can be passed as arguments to other functions, returned as values from other functions, and assigned to variables; while in Verse functions can be passed around and manipulated similarly, showcasing the functional programming paradigm. Examples include methods like Normalize(v1:vector3) and DrawDebugLine(LineStart: vector3, LineEnd: vector3). Verse supports lambda expressions and anonymous functions, allowing for inline function definitions, similar to how lambda functions are used in languages like Python or JavaScript. Verse also allows for composing functions by chaining method calls and passing functions as parameters. The declarative style used in lambda calculus is also a prominent feature of Verse for defining data transformations and computations rather than an imperative control flow model. This is seen in functions like Normalize and DrawDebugLine which are defined declaratively.
== Future plans ==
Epic Games has described Verse as the programming language for the metaverse and has factored mass scalability into its development. Until the propose
|
https://en.wikipedia.org/wiki/Verse_(programming_language)
|
In mathematics, nonlinear programming (NLP) is the process of solving an optimization problem where some of the constraints are not linear equalities or the objective function is not a linear function. An optimization problem is one of calculation of the extrema (maxima, minima or stationary points) of an objective function over a set of unknown real variables and conditional to the satisfaction of a system of equalities and inequalities, collectively termed constraints. It is the sub-field of mathematical optimization that deals with problems that are not linear.
== Definition and discussion ==
Let n, m, and p be positive integers. Let X be a subset of Rn (usually a box-constrained one), let f, gi, and hj be real-valued functions on X for each i in {1, ..., m} and each j in {1, ..., p}, with at least one of f, gi, and hj being nonlinear.
A nonlinear programming problem is an optimization problem of the form
minimize
f
(
x
)
subject to
g
i
(
x
)
≤
0
for each
i
∈
{
1
,
…
,
m
}
h
j
(
x
)
=
0
for each
j
∈
{
1
,
…
,
p
}
x
∈
X
.
{\displaystyle {\begin{aligned}{\text{minimize }}&f(x)\\{\text{subject to }}&g_{i}(x)\leq 0{\text{ for each }}i\in \{1,\dotsc ,m\}\\&h_{j}(x)=0{\text{ for each }}j\in \{1,\dotsc ,p\}\\&x\in X.\end{aligned}}}
Depending on the constraint set, there are several possibilities:
feasible problem is one for which there exists at least one set of values for the choice variables satisfying all the constraints.
an infeasible problem is one for which no set of values for the choice variables satisfies all the constraints. That is, the constraints are mutually contradictory, and no solution exists; the feasible set is the empty set.
unbounded problem is a feasible problem for which the objective function can be made to be better than any given finite value. Thus there is no optimal solution, because there is always a feasible solution that gives a better objective function value than does any given proposed solution.
Most realistic applications feature feasible problems, with infeasible or unbounded problems seen as a failure of an underlying model. In some cases, infeasible problems are handled by minimizing a sum of feasibility violations.
Some special cases of nonlinear programming have specialized solution methods:
If the objective function is concave (maximization problem), or convex (minimization problem) and the constraint set is convex, then the program is called convex and general methods from convex optimization can be used in most cases.
If the objective function is quadratic and the constraints are linear, quadratic programming te
|
https://en.wikipedia.org/wiki/Nonlinear_programming
|
Cargo cult programming is a style of computer programming characterized by the ritual inclusion of code or program structures that serve no real purpose. Cargo cult programming is symptomatic of a programmer not understanding either a bug they were attempting to solve or the apparent solution (compare shotgun debugging, deep magic). The term cargo cult programmer may apply when anyone inexperienced with the problem at hand copies some program code from one place to another with little understanding of how it works or whether it is required.
Cargo cult programming can also refer to the practice of applying a design pattern or coding style blindly without understanding the reasons behind that design principle. Some examples are adding unnecessary comments to self-explanatory code, overzealous adherence to the conventions of a programming paradigm, or adding deletion code for objects that garbage collection automatically collects.
== Etymology ==
Cargo cults are millenarian movements that arose in Melanesia under colonial rule, and inspired Richard Feynman to coin the expression cargo cult science. In Feynman's description, after the end of the Second World War practitioners believed that air delivery of cargo would resume if they carried out the proper rituals, such as building runways, lighting fires next to them, and wearing headphones carved from wood while sitting in fabricated control towers. "The form is perfect. It looks exactly the way it looked before. But it doesn’t work."
The term then became used more widely as a metaphor for empty rituals. The term "cargo-cult programming" appeared in version 2.5.1 of the Jargon File, a glossary of computing slang, released in January 1991. The term "cargo cult" in anthropology, meanwhile, is increasingly avoided for failing to represent the complexity of Melanesian beliefs.
== Cargo cult software engineering ==
A related term to cargo cult programming in software engineering is cargo cult software engineering, coined by Steve McConnell.: 23-26
McConnell describes software development organizations that attempt to emulate more successful development houses, either by slavishly following a software development process without understanding the reasoning behind it, or by attempting to emulate a commitment-oriented development approach (in which software developers devote large amounts of time and energy toward seeing their projects succeed) by mandating the long hours and unpaid overtime, while in successful companies these might instead be consequences of high motivation instead of causes of success.
In both cases, McConnell contends that competence ultimately determines whether a project succeeds or fails, regardless of the development approach taken; furthermore, he claims that incompetent "imposter organizations" (which merely imitate the form of successful software development organizations) are in fact engaging in what he calls cargo cult software engineering.: 11–13
== See also ==
Black box
Cargo cult science
Copy-and-paste programming
GitHub Copilot
Magic (programming)
Magical thinking
Vibe coding
== References ==
== Further reading ==
|
https://en.wikipedia.org/wiki/Cargo_cult_programming
|
In the field of mathematical optimization, stochastic programming is a framework for modeling optimization problems that involve uncertainty. A stochastic program is an optimization problem in which some or all problem parameters are uncertain, but follow known probability distributions. This framework contrasts with deterministic optimization, in which all problem parameters are assumed to be known exactly. The goal of stochastic programming is to find a decision which both optimizes some criteria chosen by the decision maker, and appropriately accounts for the uncertainty of the problem parameters. Because many real-world decisions involve uncertainty, stochastic programming has found applications in a broad range of areas ranging from finance to transportation to energy optimization.
== Methods ==
Several stochastic programming methods have been developed:
Scenario-based methods including Sample Average Approximation
Stochastic integer programming for problems in which some variables must be integers
Chance constrained programming for dealing with constraints that must be satisfied with a given probability
Stochastic dynamic programming
Markov decision process
Benders decomposition
== Two-stage problem definition ==
The basic idea of two-stage stochastic programming is that (optimal) decisions should be based on data available at the time the decisions are made and cannot depend on future observations. The two-stage formulation is widely used in stochastic programming. The general formulation of a two-stage stochastic programming problem is given by:
min
x
∈
X
{
g
(
x
)
=
f
(
x
)
+
E
ξ
[
Q
(
x
,
ξ
)
]
}
{\displaystyle \min _{x\in X}\{g(x)=f(x)+E_{\xi }[Q(x,\xi )]\}}
where
Q
(
x
,
ξ
)
{\displaystyle Q(x,\xi )}
is the optimal value of the second-stage problem
min
y
{
q
(
y
,
ξ
)
|
T
(
ξ
)
x
+
W
(
ξ
)
y
=
h
(
ξ
)
}
.
{\displaystyle \min _{y}\{q(y,\xi )\,|\,T(\xi )x+W(\xi )y=h(\xi )\}.}
The classical two-stage linear stochastic programming problems can be formulated as
min
x
∈
R
n
g
(
x
)
=
c
T
x
+
E
ξ
[
Q
(
x
,
ξ
)
]
subject to
A
x
=
b
|
https://en.wikipedia.org/wiki/Stochastic_programming
|
Scratch is a high-level, block-based visual programming language and website aimed primarily at children as an educational tool, with a target audience of ages 8 to 16. Users on the site can create projects on the website using a block-like interface. Scratch was conceived and designed through collaborative National Science Foundation grants awarded to Mitchel Resnick and Yasmin Kafai. Scratch is developed by the MIT Media Lab and has been translated into 70+ languages, being used in most parts of the world. Scratch is taught and used in after-school centers, schools, and colleges, as well as other public knowledge institutions. As of 15 February 2023, community statistics on the language's official website show more than 123 million projects shared by over 103 million users, and more than 95 million monthly website visits. Overall, more than 1.15 billion projects have been created in total, with the site reaching its one billionth project on April 12th, 2024.
Scratch takes its name from a technique used by disk jockeys called "scratching", where vinyl records are clipped together and manipulated on a turntable to produce different sound effects and music. Like scratching, the website lets users mix together different media (including graphics, sound, and other programs) in creative ways by creating and "remixing" projects, like video games, animations, music, and simulations.
== Scratch 3.0 ==
=== User interface ===
The Scratch interface is divided into three main sections: a stage area, block palette, and a coding area to place and arrange the blocks into scripts that can be run by pressing the green flag or clicking on the code itself. Users may also create their own code blocks, which will appear in the "My Blocks" section.
The stage area features the results (e.g., animations, turtle graphics, either in a small or normal size, with a full-screen option also available) and all sprites' thumbnails being listed in the bottom area. The stage uses x and y coordinates, with 0,0 being the stage center.
With a sprite selected at the bottom of the staging area, blocks of code can be applied by dragging them from the block palette into the coding area. The Costumes tab allows users to change the look of the sprite with a vector and bitmap editor in order to create various effects, including animation. The Sounds tab allows attaching sounds and music to a sprite.
When creating sprites and also backgrounds, users can draw their own sprites manually, choose a sprite from the library, or upload an image.
The table below shows the categories of the programming blocks:
=== Offline editing ===
An offline "Desktop Editor" for Scratch 3.0 is available for Microsoft Windows 10 and above in the Microsoft Store, Apple's macOS, ChromeOS, and Android; this allows the creation and playing of Scratch programs offline. The offline editor can also be downloaded in previous versions, such as Scratch 2.0 and Scratch 1.4 (an archive of older versions is found here).
=== Extensions ===
In Scratch, extensions add extra blocks and features that can be used in projects. In Scratch 2.0, the extensions were all hardware-based and Pen was a normal category. Software-based extensions were added in Scratch 3.0, such as text-to-speech voices, along with some new hardware-based extensions like the micro:bit. The extensions are listed below.
==== Physical ====
LEGO Mindstorms EV3 – Control motors and receive sensor data from the Lego Mindstorms EV3
Makey Makey – Use Makey Makey to control projects
LEGO Education WeDo 2.0 – control motors and receive sensor data from the Lego WeDo
micro:bit – Use of a micro:bit to control projects
LEGO BOOST – Bring robotic creations to life
Go Direct Force & Acceleration – Sense pull, push, motion, and spin
==== Digital ====
Many of the digital extensions in Scratch 3.0 used to be regular block categories that were moved to the extensions section to reduce clutter. These include:
Music – Play digital instruments (dr
|
https://en.wikipedia.org/wiki/Scratch_(programming_language)
|
Genetic programming (GP) is an evolutionary algorithm, an artificial intelligence technique mimicking natural evolution, which operates on a population of programs. It applies the genetic operators selection according to a predefined fitness measure, mutation and crossover.
The crossover operation involves swapping specified parts of selected pairs (parents) to produce new and different offspring that become part of the new generation of programs. Some programs not selected for reproduction are copied from the current generation to the new generation. Mutation involves substitution of some random part of a program with some other random part of a program. Then the selection and other operations are recursively applied to the new generation of programs.
Typically, members of each new generation are on average more fit than the members of the previous generation, and the best-of-generation program is often better than the best-of-generation programs from previous generations. Termination of the evolution usually occurs when some individual program reaches a predefined proficiency or fitness level.
It may and often does happen that a particular run of the algorithm results in premature convergence to some local maximum which is not a globally optimal or even good solution. Multiple runs (dozens to hundreds) are usually necessary to produce a very good result. It may also be necessary to have a large starting population size and variability of the individuals to avoid pathologies.
== History ==
The first record of the proposal to evolve programs is probably that of Alan Turing in 1950 in "Computing Machinery and Intelligence". There was a gap of 25 years before the publication of John Holland's 'Adaptation in Natural and Artificial Systems' laid out the theoretical and empirical foundations of the science. In 1981, Richard Forsyth demonstrated the successful evolution of small programs, represented as trees, to perform classification of crime scene evidence for the UK Home Office.
Although the idea of evolving programs, initially in the computer language Lisp, was current amongst John Holland's students, it was not until they organised the first Genetic Algorithms (GA) conference in Pittsburgh that Nichael Cramer published evolved programs in two specially designed languages, which included the first statement of modern "tree-based" Genetic Programming (that is, procedural languages organized in tree-based structures and operated on by suitably defined GA-operators). In 1988, John Koza (also a PhD student of John Holland) patented his invention of a GA for program evolution. This was followed by publication in the International Joint Conference on Artificial Intelligence IJCAI-89.
Koza followed this with 205 publications on “Genetic Programming” (GP), name coined by David Goldberg, also a PhD student of John Holland. However, it is the series of 4 books by Koza, starting in 1992 with accompanying videos, that really established GP. Subsequently, there was an enormous expansion of the number of publications with the Genetic Programming Bibliography, surpassing 10,000 entries. In 2010, Koza listed 77 results where Genetic Programming was human competitive.
The departure of GP from the rigid, fixed-length representations typical of early GA models was not entirely without precedent. Early work on variable-length representations laid the groundwork. One notable example is Messy Genetic Algorithms, which introduced irregular, variable-length chromosomes to address building block disruption and positional bias in standard GAs.
Another precursor was robot trajectory programming, where genome representations encoded program instructions for robotic movements—structures inherently variable in length.
Even earlier, unfixed-length representations were proposed in a doctoral dissertation by Cavicchio, who explored adaptive search using simulated evolution. His work provided foundational ideas for flexible program structures.
In 1996, K
|
https://en.wikipedia.org/wiki/Genetic_programming
|
In computer programming, a block or code block or block of code is a lexical structure of source code which is grouped together. Blocks consist of one or more declarations and statements. A programming language that permits the creation of blocks, including blocks nested within other blocks, is called a block-structured programming language. Blocks are fundamental to structured programming, where control structures are formed from blocks.
Blocks have two functions: to group statements so that they can be treated as one statement, and to define scopes for names to distinguish them from the same name used elsewhere. In a block-structured programming language, the objects named in outer blocks are visible inside inner blocks, unless they are masked by an object declared with the same name.
== History ==
Ideas of block structure were developed in the 1950s during the development of the first autocodes, and were formalized in the Algol 58 and Algol 60 reports. Algol 58 introduced the notion of the "compound statement", which was related solely to control flow. The subsequent Revised Report which described the syntax and semantics of Algol 60 introduced the notion of a block and block scope, with a block consisting of " A sequence of declarations followed by a sequence of statements and enclosed between begin and end..." in which "[e]very declaration appears in a block in this way and is valid only for that block."
== Syntax ==
Blocks use different syntax in different languages. Several broad families are:
the ALGOL family in which blocks are delimited by the keywords "begin" and "end" or equivalent. In C, blocks are delimited by curly braces - "{" and "}". ALGOL 68 uses parentheses.
Parentheses - "(" and ")", are used in the MS-DOS batch language
indentation, as in Python and Haskell
s-expressions with a syntactic keyword such as prog or let (as in the Lisp family)
In 1968 (with ALGOL 68), then in Edsger W. Dijkstra's 1974 Guarded Command Language the conditional and iterative code block are alternatively terminated with the block reserved word reversed: e.g. if ~ then ~ elif ~ else ~ fi, case ~ in ~ out ~ esac and for ~ while ~ do ~ od
== Limitations ==
Some languages which support blocks with declarations do not fully support all declarations; for instance many C-derived languages do not permit a function definition within a block (nested functions). And unlike its ancestor Algol, Pascal does not support the use of blocks with their own declarations inside the begin and end of an existing block, only compound statements enabling sequences of statements to be grouped together in if, while, repeat and other control statements.
== Basic semantics ==
The semantic meaning of a block is twofold. Firstly, it provides the programmer with a way for creating arbitrarily large and complex structures that can be treated as units. Secondly, it enables the programmer to limit the scope of variables and sometimes other objects that have been declared.
In early languages such as Fortran IV and BASIC, there were no statement blocks or control structures other than simple forms of loops. Conditionals were implemented using conditional goto statements:
The logical structure of the program is not reflected in the language, and analyzing when a given statement is executed can be difficult.
Blocks allow the programmer to treat a group of statements as a unit, and the default values which had to appear in initialization in this style of programming can, with a block structure, be placed closer to the decision:
Use of blocks in the above fragment of Pascal clarifies the programmer's intent, and enables combining the resulting blocks into a nested hierarchy of conditional statements. The structure of the code reflects the programmer's thinking more closely, making it easier to understand and modify.
The above source code can be made even clearer by taking the inner if statement out of the outer one altogether, placing the two blocks one after
|
https://en.wikipedia.org/wiki/Block_(programming)
|
Strip programming or stripping is a technique used for scheduling television and radio programming to ensure consistency and coherency. Television or radio programs of a particular style (such as a television series) are given a regular daily time slot during the week, so that it appears as a strip straight across the weekly schedule. For example, radio and television broadcasters may program a news program at rush hours every day, or at least every weekday.
Strip programming is used to deliver consistent content to targeted audiences. Broadcasters know or predict the times at which certain demographics will be listening to or watching their programs and play them at that time. Most television dayparts outside of prime time use strip programming five days a week (with some selected programs also being stripped on one or both days of the weekend), with the same programs being broadcast every day at the same time to target specific demographics. Strip programming is sometimes criticized as making programming too predictable, and reducing diversity and uniqueness.
== Overview ==
Strip scheduling often applies to any program that airs on multiple consecutive days during the calendar week (most commonly Monday through Friday), whether carried through a television network (such as with a talk show, news program, soap opera, or telenovela) or in syndication. It is commonly restricted to describing the airing of television programs that were originally broadcast on a weekly basis during their original run: The West Wing could be stripped but not Jeopardy!, as Jeopardy! was originally intended to be run daily. It can also refer to shows in prime time that run daily, such as with the short-lived The Jay Leno Show in 2009 and 2010.
For much of the 1960s and into the early 1990s, stripping for syndication was one of, if not the primary profit component of the studio production model in American television. A show became far more profitable if it succeeded in getting three full U.S. seasons (about 75 episodes) or more, as then it was possible to strip it for fifteen weeks (15×5=75) before needing to repeat episodes. Once a series attained five seasons (which would push the show over the 100 episodes threshold), it would be a full six months before it would repeat. For Star Trek, in particular, this was relevant. Only due to an unprecedented letter-writing campaign was the show renewed for its third season, and it did not begin to attain wider popularity until appearing in syndication for a number of years. If it had failed to be renewed for a third season, it would not have been syndicated, and its subsequent popularity and influence would likely not have occurred. Many other shows with lukewarm response in their initial runs became widely appreciated cult favorites as a result of syndication, or helped keep cultural memes associated with them far more widely known than if the shows had only been viewable during their initial time frame.
Michael Grade was responsible for introducing stripped and stranded schedules to the BBC's television service in the United Kingdom in his role as controller of BBC1: from February 18, 1985, onward, the weekday evening schedule has consisted almost entirely of half-hour or hour-long programs starting on the hour, or half-hour (the BBC channels never carried spot advertising). For example, Grade's new schedule provided at 19:00, the talk show Wogan thrice weekly and two episodes of EastEnders and fixed the national news at 18:00 and 21:00, and regional news at 18:30. Before this date, programs might start at almost any time and programs could have different times on consecutive weeks or even days, for example:
Compare with a 2007 schedule for the same channel:
Stripping has also become an even more common practice on many British channels since the introduction of multi-channel cable and satellite television in the 1990s.
In many other countries, new episodes of various series are aired every weekday. F
|
https://en.wikipedia.org/wiki/Strip_programming
|
Block programming (also known as a strand in British broadcasting) is the arrangement of programs on radio or television so that those of a particular genre, theme, or target audience are united.
== Overview ==
Block programming involves scheduling a series of related shows which are likely to attract and hold a given audience for a long period of time. Notable examples of overt block programming were NBC's Thursday evening "Must See TV" lineup, which included two hours of sitcoms and one hour of ER, All TV's "Jeepney TV sa All TV" lineup, which consisting the replay of selected Filipino drama series produced by ABS-CBN Studios, a simulcast of ABS-CBN's daily morning talk show Magandang Buhay, and a simulcast of ABS-CBN News' afternoon newscast TV Patrol Express, and Channel 4's "T4" program which often ran sitcoms back-to-back for an hour or more. Reruns on cable television are often assembled into similar blocks to fill several hours of generally little-watched daytime periods. A particularly long program block, especially one that does not air on a regular schedule, is known as a marathon.
Block programming in radio also refers to programming content that appeals to various demographics in time blocks, usually corresponding to the top or bottom of the hour or the quarter-hour periods. For example, various musical genres might be featured, such as a country music hour, a three-hour afternoon block of jazz, or a four-hour Saturday night '70s disco show.
Generally speaking, block programming is anathema to modern competitive commercial radio, which traditionally uses uniform formats, other than a handful of speciality shows in off-peak hours such as weekends (for instance, the infamous beaver hours in Canadian radio). The general rationale for not using block programming is that listeners expect a certain type of music when they tune into a radio station and breaking from that format will turn those listeners away from the station; likewise, a station that airs its programming in hodgepodge blocks will have difficulty building listener loyalty, as listeners' music will only be on for a few hours of the day. This argument for homogenized radio was also a driving force behind the effective death of freeform radio in the late 20th century. The case of talk radio is indicative of the decline of block programming: prior to the 1980s, it was not uncommon to mix various blocks of talk programming together on one station, but this has declined dramatically in the late 1990s and beyond. A listener to a conservative talk radio station will have little interest in a progressive talk radio, sports radio or hot talk block, which reaches a different demographic; stations that have attempted the block strategy have historically been unsuccessful. Block programming of this nature is alive and well on outlets like public radio (such as NPR, the BBC, or CBC) and in multicultural radio serving broad ethnic and cultural audiences, although even in this realm the idea of block programming is declining due to competition for donations.
Some programming blocks have become so popular that they have been transformed to full-fledged 24-hour channels. Current channels which started as program blocks include Disney Jr. (which is still a program block on Disney Channel); the Nick Jr. Channel (based on the Nick Jr. block that still airs on Nickelodeon); Boomerang (which was once a program block on Cartoon Network); PBS Kids (which is still a program block on PBS) and MeTV Toons (which was once a programming block on MeTV). In addition, TV Land airs older shows that were once aired on sister channel Nickelodeon's Nick at Nite program block. Adult Swim is also a Cartoon Network programming block.
However, since the 2010s, new programming blocks have become rare due to airing programming in a regular format or with little or no brand reference within the programming block.
== See also ==
Audience flow
Lists of programming blocks
Strip programming
Broadca
|
https://en.wikipedia.org/wiki/Block_programming
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.