doctype

There are three XHTML 1.0 doctypes available […]

2006, Paul Haine, HTML mastery: semantics, standards, and styling:

Common idiosyncrasies that appear in web pages that don't have doctypes include varying text sizes and varying margin space between elements.

2007, Matthew MacDonald, Beginning ASP.NET 3.5 in C# 2008:

Most Web page editing programs add an appropriate doctype when you create a new Web page […]

2008, David Sawyer McFarland, JavaScript: The Missing Manual:

(programming) A directive that associates an SGML or XML document (such as a webpage) with a Document Type Definition, potentially affecting how it is parsed and rendered.


bitfield

bitfields (plural)
bit field (alternative)

(programming) A sequence of bits (binary digits) which can be toggled individually as flags.


DAWG

directed acyclic word graph
directed acyclic word graph#English

(programming) Initialism of directed acyclic word graph.


multiton

(programming) The class used for the multiton pattern.


değişken

head

değişken (definite accusative değişkeni, plural değişkenler)

değişkeni (accusative definite)
değişkenler (plural)
değişken (nominative singular)
değişkenler (nominative plural)
değişkeni (accusative definite singular)
değişkenleri (accusative definite plural)
değişkene (dative singular)
değişkenlere (dative plural)
değişkende (locative singular)
değişkenlerde (locative plural)
değişkenden (ablative singular)
değişkenlerden (ablative plural)
değişkenin (genitive singular)
değişkenlerin (genitive plural)
değişkenim (first-person nominative singular)
değişkenlerim (first-person nominative singular)
değişkenin (nominative second-person singular)
değişkenlerin (nominative second-person singular)
değişkeni (nominative singular third-person)
değişkenleri (nominative singular third-person)
değişkenimiz (first-person nominative plural)
değişkenlerimiz (first-person nominative plural)
değişkeniniz (nominative plural second-person)
değişkenleriniz (nominative plural second-person)
değişkenleri (nominative plural third-person)
değişkenimi (accusative definite first-person singular)
değişkenlerimi (accusative definite first-person singular)
değişkenini (accusative definite second-person singular)
değişkenlerini (accusative definite second-person singular)
değişkenini (accusative definite singular third-person)
değişkenlerini (accusative definite singular third-person)
değişkenimizi (accusative definite first-person plural)
değişkenlerimizi (accusative definite first-person plural)
değişkeninizi (accusative definite plural second-person)
değişkenlerinizi (accusative definite plural second-person)
değişkenlerini (accusative definite plural third-person)
değişkenime (dative first-person singular)
değişkenlerime (dative first-person singular)
değişkenine (dative second-person singular)
değişkenlerine (dative second-person singular)
değişkenine (dative singular third-person)
değişkenlerine (dative singular third-person)
değişkenimize (dative first-person plural)
değişkenlerimize (dative first-person plural)
değişkeninize (dative plural second-person)
değişkenlerinize (dative plural second-person)
değişkenlerine (dative plural third-person)
değişkenimde (first-person locative singular)
değişkenlerimde (first-person locative singular)
değişkeninde (locative second-person singular)
değişkenlerinde (locative second-person singular)
değişkeninde (locative singular third-person)
değişkenlerinde (locative singular third-person)
değişkenimizde (first-person locative plural)
değişkenlerimizde (first-person locative plural)
değişkeninizde (locative plural second-person)
değişkenlerinizde (locative plural second-person)
değişkenlerinde (locative plural third-person)
değişkenimden (ablative first-person singular)
değişkenlerimden (ablative first-person singular)
değişkeninden (ablative second-person singular)
değişkenlerinden (ablative second-person singular)
değişkeninden (ablative singular third-person)
değişkenlerinden (ablative singular third-person)
değişkenimizden (ablative first-person plural)
değişkenlerimizden (ablative first-person plural)
değişkeninizden (ablative plural second-person)
değişkenlerinizden (ablative plural second-person)
değişkenlerinden (ablative plural third-person)
değişkenimin (first-person genitive singular)
değişkenlerimin (first-person genitive singular)
değişkeninin (genitive second-person singular)
değişkenlerinin (genitive second-person singular)
değişkeninin (genitive singular third-person)
değişkenlerinin (genitive singular third-person)
değişkenimizin (first-person genitive plural)
değişkenlerimizin (first-person genitive plural)
değişkeninizin (genitive plural second-person)
değişkenlerinizin (genitive plural second-person)
değişkenlerinin (genitive plural third-person)
değişkenim (first-person singular)
değişkenlerim (first-person singular)
değişkensin (second-person singular)
değişkenlersin (second-person singular)
değişken (singular third-person)
değişkendir (singular third-person)
değişkenler (singular third-person)
değişkenlerdir (singular third-person)
değişkeniz (first-person plural)
değişkenleriz (first-person plural)
değişkensiniz (plural second-person)
değişkenlersiniz (plural second-person)
değişkenler (plural third-person)
değişkenlerdir (plural third-person)

Mrphologically değiş- (“to change”) + -ken (“habitual suffix”)


multiple inheritance

object-oriented programming
object-oriented programming

(programming, object-oriented programming) The ability to inherit from more than one superclass in a single subclass.

vícenásobná dědičnost

in programming: inheriting from multiple superclasses


zamknąć

zamykać (imperfective)
zamknąć (infinitive)
zamknę (future singular)
zamkniemy (future plural)
zamkniesz (future singular)
zamkniecie (future plural)
zamknie (future singular third-person)
zamkną (future plural third-person)
zamknie się (future impersonal)
zamknąłem (masculine past singular)
-(e)m zamknął (masculine past singular)
zamknęłam (feminine past singular)
-(e)m zamknęła (feminine past singular)
zamknęłom (neuter past singular)
-(e)m zamknęło (neuter past singular)
zamknęliśmy (past plural virile)
-(e)śmy zamknęli (past plural virile)
zamknęłyśmy (nonvirile past plural)
-(e)śmy zamknęły (nonvirile past plural)
zamknąłeś (masculine past singular)
-(e)ś zamknął (masculine past singular)
zamknęłaś (feminine past singular)
-(e)ś zamknęła (feminine past singular)
zamknęłoś (neuter past singular)
-(e)ś zamknęło (neuter past singular)
zamknęliście (past plural virile)
-(e)ście zamknęli (past plural virile)
zamknęłyście (nonvirile past plural)
-(e)ście zamknęły (nonvirile past plural)
zamknął (masculine past singular third-person)
zamknęła (feminine past singular third-person)
zamknęło (neuter past singular third-person)
zamknęli (past plural third-person virile)
zamknęły (nonvirile past plural third-person)
zamknięto (impersonal past)
zamknąłbym (conditional masculine singular)
bym zamknął (conditional masculine singular)
zamknęłabym (conditional feminine singular)
bym zamknęła (conditional feminine singular)
zamknęłobym (conditional neuter singular)
bym zamknęło (conditional neuter singular)
zamknęlibyśmy (conditional plural virile)
byśmy zamknęli (conditional plural virile)
zamknęłybyśmy (conditional nonvirile plural)
byśmy zamknęły (conditional nonvirile plural)
zamknąłbyś (conditional masculine singular)
byś zamknął (conditional masculine singular)
zamknęłabyś (conditional feminine singular)
byś zamknęła (conditional feminine singular)
zamknęłobyś (conditional neuter singular)
byś zamknęło (conditional neuter singular)
zamknęlibyście (conditional plural virile)
byście zamknęli (conditional plural virile)
zamknęłybyście (conditional nonvirile plural)
byście zamknęły (conditional nonvirile plural)
zamknąłby (conditional masculine singular third-person)
by zamknął (conditional masculine singular third-person)
zamknęłaby (conditional feminine singular third-person)
by zamknęła (conditional feminine singular third-person)
zamknęłoby (conditional neuter singular third-person)
by zamknęło (conditional neuter singular third-person)
zamknęliby (conditional plural third-person virile)
by zamknęli (conditional plural third-person virile)
zamknęłyby (conditional nonvirile plural third-person)
by zamknęły (conditional nonvirile plural third-person)
zamknięto by (conditional impersonal)
niech zamknę (imperative singular)
zamknijmy (imperative plural)
zamknij (imperative singular)
zamknijcie (imperative plural)
niech zamknie (imperative singular third-person)
niech zamkną (imperative plural third-person)
zamknięty (adjectival masculine participle passive singular)
zamknięta (adjectival feminine participle passive singular)
zamknięte (adjectival neuter participle passive singular)
zamknięci (adjectival participle passive plural virile)
zamknięte (adjectival nonvirile participle passive plural)
zamknąwszy (adverbial anterior participle)
zamknięcie (noun-from-verb)

(transitive, programming) to close, close out, exit, shut down (of a program)


nonliteral

(programming, logic) That which is not a literal.


Maschinensprache

de-noun

Maschinensprache f (genitive Maschinensprache, plural Maschinensprachen)

Maschinensprache (genitive)
Maschinensprachen (plural)
Maschinensprache (nominative singular)
Maschinensprachen (definite nominative plural)
Maschinensprache (genitive singular)
Maschinensprachen (definite genitive plural)
Maschinensprache (dative singular)
Maschinensprachen (dative definite plural)
Maschinensprache (accusative singular)
Maschinensprachen (accusative definite plural)

/maˈʃiːnənˌʃpʁaːχə/

Maschine (“machine”) + -n- + Sprache (“language”)

affix

(programming) machine language (set of instructions for a computer)


uniquid

(programming, in the PHP programming language) A random identifier based on the system time.


programador

ca-noun

programador m (plural programadors, feminine programadora)

programadors (plural)
programadora (feminine)

(computing) programmer (one who writes computer programs)


programador

gl-noun

programador m (plural programadores, feminine programadora, feminine plural programadoras)

programadores (plural)
programadora (feminine)
programadoras (feminine plural)


programador

[pɾu.ɣɾɐ.mɐˈðoɾ]

[pɾu.ɣɾɐ.mɐˈðoɾ]

(computing) programmer (one who writes software)


nonprimitive

LL-Q1860 (eng)-Flame, not lame-nonprimitive.wav

(programming, computer graphics, geometry) An object that is not a primitive.


monkey patch

monkey patches (plural)
monkeypatch (alternative)
monkey-patch (alternative)

Apparently from earlier guerrilla patch (“code that sneakily changes other code”), understood as gorilla patch. A monkey patch was then a more carefully written instance of such a patch. Or simply derived from monkey (“to mess with”, verb).

(programming slang) A patch which alters the behaviour of a program by forcibly overriding aspects of the original code at runtime.


monkey patch

en-verb

monkey patch (third-person singular simple present monkey patches, present participle monkey patching, simple past and past participle monkey patched)

monkey patches (present singular third-person)
monkey patching (participle present)
monkey patched (participle past)
monkey patched (past)
monkeypatch (alternative)
monkey-patch (alternative)

Even though that works with some browsers, others provide Anchor objects without click() methods. Add this magic code to your application.js, to Monkey Patch a JavaScript click() event:

2007, Philip C. Plumlee, Test Driven Ajax (on Rails):

(programming slang, transitive) To alter the behaviour of a program by forcibly overriding aspects of the original code at runtime.


pointcut

(computing, programming) In aspect-oriented programming, a set of join points specifying when advice should run during execution.


πηγαίος κώδικας

head

πηγαίοι κώδικες

πηγαίος κώδικας • (pigaíos kódikas) m (plural πηγαίοι κώδικες)

el-noun

πηγαίοι κώδικες

pigaíos kódikas (romanization)
πηγαίοι κώδικες (plural)

(computing, programming, uncountable) source code


memberwise

If a copy constructor is not defined, a memberwise copy is performed. This means that a copy operation is applied to each data member in turn.

1997, Adrian P Robson, The programmer's guide to C++:

(computing, programming) In terms of members (items associated with class instances).


forritunarmál

is-noun

forritunarmál n (genitive singular forritunarmáls, nominative plural forritunarmál)

forritunarmáls (genitive singular)
forritunarmál (nominative plural)
forritunarmál (indefinite nominative singular)
forritunarmálið (definite nominative singular)
forritunarmál (indefinite nominative plural)
forritunarmálin (definite nominative plural)
forritunarmál (accusative indefinite singular)
forritunarmálið (accusative definite singular)
forritunarmál (accusative indefinite plural)
forritunarmálin (accusative definite plural)
forritunarmáli (dative indefinite singular)
forritunarmálinu (dative definite singular)
forritunarmálum (dative indefinite plural)
forritunarmálunum (dative definite plural)
forritunarmáls (genitive indefinite singular)
forritunarmálsins (definite genitive singular)
forritunarmála (genitive indefinite plural)
forritunarmálanna (definite genitive plural)

From forritun (“programming”) + mál (“language”).

compound

programming language
programming language


join point

(programming) In aspect-oriented programming, a point at which advice (additional code) is triggered (a set of these constituting a pointcut).


directed acyclic word graph

en-noun

directed acyclic word graph (plural directed acyclic word graphs)

(programming) A data structure that represents a set of strings and allows for a query operation that tests whether a given string belongs to the set in time proportional to its length (thus more efficient in some situations than a trie).


autoloader

(programming) A software mechanism that automatically locates and loads classes etc. as required at run time.


dead code

Many software projects contain much dead code in the form of deprecated functions.

If the test data is exhaustive you can even locate dead code: program code that is never executed.

2003, Diomidis Spinellis, Code Reading: The Open Source Perspective, Addison-Wesley Professional, →ISBN, page 372:

(programming) A portion of source code that will never be executed as part of the running program.


infinite loop

(programming) A loop which continues indefinitely.


wyrażenie

wyrażenie (nominative singular)
wyrażenia (nominative plural)
wyrażenia (genitive singular)
wyrażeń (genitive plural)
wyrażeniu (dative singular)
wyrażeniom (dative plural)
wyrażenie (accusative singular)
wyrażenia (accusative plural)
wyrażeniem (instrumental singular)
wyrażeniami (instrumental plural)
wyrażeniu (locative singular)
wyrażeniach (locative plural)
wyrażenie (singular vocative)
wyrażenia (plural vocative)

From wyrazić + -enie. Compare Russian выраже́ние (vyražénije) or English expression.

(countable, formal languages, mathematics, programming) expression


programowanie

programowanie (nominative singular)
programowania (genitive singular)
programowaniu (dative singular)
programowanie (accusative singular)
programowaniem (instrumental singular)
programowaniu (locative singular)
programowanie (singular vocative)


メンバー

ja-noun

メンバー • (menbā)

(programming) member in object-oriented programming


genérico

pt-adj

genérico (feminine genérica, masculine plural genéricos, feminine plural genéricas)

genérica (feminine)
genéricos (masculine plural)
genéricas (feminine plural)

(programming) generic (written so as to operate on any data type)


שפת תכנות

he-noun

שְׂפַת תִּכְנוּת

שְׂפוֹת תִּכְנוּת

שְׂפַת תִּכְנוּת • (s'fat tikh'nut) f (plural indefinite [שפה|שְׂפַת]]_תִּכְנוּת " lang="he">שְׂפוֹת תִּכְנוּת)

שְׂפַת תִּכְנוּת (canonical)
s'fat tikh'nut (romanization)
שְׂפוֹת תִּכְנוּת (indefinite plural)

programming language
programming language#English:_Q9143


klasi

is-noun

klasi m (genitive singular klasa, nominative plural klasar)

klasa (genitive singular)
klasar (nominative plural)
klasi (indefinite nominative singular)
klasinn (definite nominative singular)
klasar (indefinite nominative plural)
klasarnir (definite nominative plural)
klasa (accusative indefinite singular)
klasann (accusative definite singular)
klasa (accusative indefinite plural)
klasana (accusative definite plural)
klasa (dative indefinite singular)
klasanum (dative definite singular)
klösum (dative indefinite plural)
klösunum (dative definite plural)
klasa (genitive indefinite singular)
klasans (definite genitive singular)
klasa (genitive indefinite plural)
klasanna (definite genitive plural)


Lisplike

en-adj

Lisplike (comparative more Lisplike, superlative most Lisplike)

more Lisplike (comparative)
most Lisplike (superlative)

(programming) Resembling or characteristic of the programming language Lisp.


frob

en-verb

frob (third-person singular simple present frobs, present participle frobbing, simple past and past participle frobbed)

frobs (present singular third-person)
frobbing (participle present)
frobbed (participle past)
frobbed (past)

Clipping of frobnicate, from frobnitz, coined circa 1958 by David R. Sawyer of the MIT Tech Model Railroad Club (TMRC). Year of origin uncertain, and could be 1958–1981: frob is not listed in the TMRC dictionaries of 1959 or 1960, and is first listed in the Jargon File (1981 edition), so it may date from the 1960s or 1970s. Possibly variant of or influenced by frotsus (“a protruding arm or trunnion”), which is listed in TMRC 1959 and 1960.

(programming, Linux, Gnu C) To transform and obscure in a trivial fashion with memfrob(3).


goroutine

From Go (“programming language”) + routine, to rhyme with coroutine.

Exercise 14.8: Starting from the Fibonacci-program in Listing 6.10, make a solution which isolates the calculation of the Fibonacci-terms in a goroutine, which sends these results on a channel. Close the channel when finished.

2012, Ivo Balbaert, The Way to Go, page 406:

(programming) A lightweight communicating process in the Go programming language.


tight loop

(programming) A loop which contains few instructions and iterates many times.

(programming) Such a loop which heavily uses I/O or processing resources, failing to adequately share them with other programs running in the operating system.


critical section

en-noun

critical section (plural critical sections)

The instructions between a lock and an unlock form a critical section.

2011, Ganesh Gopalakrishnan, Shaz Qadeer, Computer Aided Verification: 23rd International Conference:

(programming) A piece of code that accesses a shared resource that must not be concurrently accessed by more than one thread of execution.


RAII

With RAII, the closing action cannot be skipped or bypassed, even if the function exits the scope prematurely with an early return or by throwing an exception.

2019, Fedor G. Pikus, Hands-On Design Patterns with C++, page 469:

(programming) Initialism of Resource Acquisition Is Initialization, a popular design pattern in object-oriented programming that ties resources to the lifespan of associated objects to prevent resource leakage.

CADRe

Constructor Acquires, Destructor Releases


رویه

From رو (rav-, present stem of رفتن (raftan, “to go”)) + ـیه (-iyye).

af

رو
<pos:present stem of <i class="Arab fa-Arab mention" lang="fa">رفتن</i> (raftan, “to go”)>


JAPH

(computing, programming) A program written in Perl that outputs the text Just another Perl hacker, usually programmed in an obfuscated manner so that the output is not obvious until it is run.


monada

monada (nominative singular)
monady (nominative plural)
monady (genitive singular)
monad (genitive plural)
monadzie (dative singular)
monadom (dative plural)
monadę (accusative singular)
monady (accusative plural)
monadą (instrumental singular)
monadami (instrumental plural)
monadzie (locative singular)
monadach (locative plural)
monado (singular vocative)
monady (plural vocative)

Learned borrowing from Latin monas, from Ancient Greek μονάς (monás), from μόνος (mónos), from Proto-Indo-European *mey-.

(category theory, programming) monad (mathematics and computing term)


KLOC

From K (“thousand”) + LOC (“lines of code”).

The formula is based on thousands of lines of source code (kLOC) and incorporates Fagan's recommendations for inspection pace, meeting duration, and frequency:
elapsed time (in days) = 3 × n kLOC
Here n is an estimate of how many thousands of lines of code will be inspected.

1991, Glen W. Russell, Experience with Inspection in Ultralarge-Scale Developments (Bell-Northern Research)

It concludes that defects are found 2 to 4 times faster with inspection than with testing, that defects are typically found at the rate of one defect per man hour invested in inspection, and that inspection finds about 37 defects per kloc if it is done properly.

1993, Terry Shepard in Proceedings of the National Workshop on Software Engineering Education (IBM Canada)

In IBM there's a religion in software that says you have to count KLOCs, and a KLOC is a thousand line of code.

1996, Steve Ballmer in Triumph of the Nerds II: Riding the Bear (Robert X. Cringely, Paul Sen), about 38 minutes in, relating events around 1989

(computing, programming) Abbreviation of thousand lines of code.


BCPL

Programming Language
programming language#English

(programming) Initialism of Basic Combined Programming Language: a programming language of the 1960s intended for writing compilers and on which the later language C was based.


programski jezik

sh-noun

prògramskī jèzik m (Cyrillic spelling про̀грамскӣ јѐзик)

prògramskī jèzik (canonical masculine)
про̀грамскӣ јѐзик (Cyrillic)

programming language (code of reserved words and symbols)


MFC

Microsoft Foundation Classes
w:Microsoft Foundation Classes

(programming) Initialism of Microsoft Foundation Classes.


strong typing

(computing, programming) A system that places any of various kinds of restriction on the interactions between objects of different data types.


`num`

head

# (English symbol name number sign or hash or pound sign or octothorpe)

number sign (English name symbol)
hash (English name symbol)
pound sign (English name symbol)
octothorpe (English name symbol)

(programming) Used to indicate a hexadecimal color code.


`period`

The periodos of Aristophanes of Byzantium, ca. 200 BCE. Originally there were three dots: ⟨·⟩ at mid height (the comma), ⟨.⟩ at the baseline (the colon), and ⟨˙⟩ at capital height (the periodos). When minuscule writing became common, it proved difficult to make a three-way height distinction, and only the periodos was retained, though it shifted to the baseline.

point.x

the ‘x’ property of the ‘point’ variable

programming language
programming language#English

In various programming languages, the structure access operator.

echo 'I am currently ' . myAge(1981) . ' old.';

In various programming languages, the string concatenation operator.

ls .

list the contents of the current directory

In various operating systems, the current directory.

div.quotedtext {font-style: italic}

The class selector in CSS, which intends to format a class of an element. (A class can appear freely one or more times in a page, as opposed to the ID selector: #).

document.txt

the file with the base name ‘document’ and the extension ‘txt’

Separates a file name from its extension.

en.wiktionary.org

the Internet domain name with components ‘en’, ‘wiktionary’, and ‘org’

top-level domain
top-level domain#English

Separates the parts of the domain name of a website (including the subdomain and the top-level domain).

version 1.2.16

Separates the parts of a version number.

Separates the parts of an IP address (IPv4).

(regular expressions) Matches any single character.


`lowbar`

_ (English symbol name underscore or underline)

underscore (English name symbol)
underline (English name symbol)

] [
Unsupported titles/Space#Translingual

(computing) Used to represent what would normally be a space ] [ in computing.

(programming) Especially as a prefix: used to denote a special identifier such as a global or private variable or a reserved symbol.


`vert`

| (English symbol name vertical bar or vertical line or pipe or pipe key)

vertical bar (English name symbol)
vertical line (English name symbol)
pipe (English name symbol)
pipe key (English name symbol)

(programming) Used in some programming languages as the "bitwise or" operator.


(programming) A namespace or scope resolution operator in some programming languages.


(computing, programming) Assignment. Indicates the that the value or computed expression on the right is to be stored in the variable or address location on the left.


`lt``gt`

(mathematics, programming) Not equal to.


subarray

(programming) A contiguous subset of an array.


ponteiro

talhadeira

antonym(s) of “masonry chisel with a pointy tip”

(programming) variable that holds the address of a memory location


apuntador

es-noun

apuntador m (plural apuntadores, feminine apuntadora, feminine plural apuntadoras)

apuntadores (plural)
apuntadora (feminine)
apuntadoras (feminine plural)


programação

/pɾu.ɡɾɐ.mɐˈsɐ̃w̃/

[pɾu.ɣɾɐ.mɐˈsɐ̃w̃]

From programa (“programme”) + -ção (“-tion”), from Late Latin programma (“a proclamation, edict”), from Ancient Greek πρόγραμμα (prógramma, “a written public notice, an edict”), from προγράφω (prográphō, “to set forth as a public notice”), from πρό (pró, “before”) + γράφω (gráphō, “to write”).

der

(programming, uncountable) programming (the development of computer software)


programować

pl-verb

programować impf (perfective zaprogramować)

zaprogramować (perfective)
programować (infinitive)
programuję (present singular)
programujemy (plural present)
programujesz (present singular)
programujecie (plural present)
programuje (present singular third-person)
programują (plural present third-person)
programuje się (impersonal present)
programowałem (masculine past singular)
-(e)m programował (masculine past singular)
programowałam (feminine past singular)
-(e)m programowała (feminine past singular)
programowałom (neuter past singular)
-(e)m programowało (neuter past singular)
programowaliśmy (past plural virile)
-(e)śmy programowali (past plural virile)
programowałyśmy (nonvirile past plural)
-(e)śmy programowały (nonvirile past plural)
programowałeś (masculine past singular)
-(e)ś programował (masculine past singular)
programowałaś (feminine past singular)
-(e)ś programowała (feminine past singular)
programowałoś (neuter past singular)
-(e)ś programowało (neuter past singular)
programowaliście (past plural virile)
-(e)ście programowali (past plural virile)
programowałyście (nonvirile past plural)
-(e)ście programowały (nonvirile past plural)
programował (masculine past singular third-person)
programowała (feminine past singular third-person)
programowało (neuter past singular third-person)
programowali (past plural third-person virile)
programowały (nonvirile past plural third-person)
programowano (impersonal past)
będę programował (future masculine singular)
będę programować (future masculine singular)
będę programowała (feminine future singular)
będę programować (feminine future singular)
będę programowało (future neuter singular)
będę programować (future neuter singular)
będziemy programowali (future plural virile)
będziemy programować (future plural virile)
będziemy programowały (future nonvirile plural)
będziemy programować (future nonvirile plural)
będziesz programował (future masculine singular)
będziesz programować (future masculine singular)
będziesz programowała (feminine future singular)
będziesz programować (feminine future singular)
będziesz programowało (future neuter singular)
będziesz programować (future neuter singular)
będziecie programowali (future plural virile)
będziecie programować (future plural virile)
będziecie programowały (future nonvirile plural)
będziecie programować (future nonvirile plural)
będzie programował (future masculine singular third-person)
będzie programować (future masculine singular third-person)
będzie programowała (feminine future singular third-person)
będzie programować (feminine future singular third-person)
będzie programowało (future neuter singular third-person)
będzie programować (future neuter singular third-person)
będą programowali (future plural third-person virile)
będą programować (future plural third-person virile)
będą programowały (future nonvirile plural third-person)
będą programować (future nonvirile plural third-person)
będzie programować się (future impersonal)
programowałbym (conditional masculine singular)
bym programował (conditional masculine singular)
programowałabym (conditional feminine singular)
bym programowała (conditional feminine singular)
programowałobym (conditional neuter singular)
bym programowało (conditional neuter singular)
programowalibyśmy (conditional plural virile)
byśmy programowali (conditional plural virile)
programowałybyśmy (conditional nonvirile plural)
byśmy programowały (conditional nonvirile plural)
programowałbyś (conditional masculine singular)
byś programował (conditional masculine singular)
programowałabyś (conditional feminine singular)
byś programowała (conditional feminine singular)
programowałobyś (conditional neuter singular)
byś programowało (conditional neuter singular)
programowalibyście (conditional plural virile)
byście programowali (conditional plural virile)
programowałybyście (conditional nonvirile plural)
byście programowały (conditional nonvirile plural)
programowałby (conditional masculine singular third-person)
by programował (conditional masculine singular third-person)
programowałaby (conditional feminine singular third-person)
by programowała (conditional feminine singular third-person)
programowałoby (conditional neuter singular third-person)
by programowało (conditional neuter singular third-person)
programowaliby (conditional plural third-person virile)
by programowali (conditional plural third-person virile)
programowałyby (conditional nonvirile plural third-person)
by programowały (conditional nonvirile plural third-person)
programowano by (conditional impersonal)
niech programuję (imperative singular)
programujmy (imperative plural)
programuj (imperative singular)
programujcie (imperative plural)
niech programuje (imperative singular third-person)
niech programują (imperative plural third-person)
programujący (active adjectival masculine participle singular)
programująca (active adjectival feminine participle singular)
programujące (active adjectival neuter participle singular)
programujący (active adjectival participle plural virile)
programujące (active adjectival nonvirile participle plural)
programowany (adjectival masculine participle passive singular)
programowana (adjectival feminine participle passive singular)
programowane (adjectival neuter participle passive singular)
programowani (adjectival participle passive plural virile)
programowane (adjectival nonvirile participle passive plural)
programując (adjectival contemporary participle)
programowanie (noun-from-verb)

(transitive) to program (to enter a program or other instructions into a computer)

(literary, transitive) to program (a person to think a certain way)


костыль

ru-noun+

косты́ль • (kostýlʹ) m inan (genitive костыля́, nominative plural костыли́, genitive plural костыле́й, relational adjective косты́льный)

косты́ль (canonical)
kostýlʹ (romanization)
костыля́ (genitive)
костыли́ (nominative plural)
костыле́й (genitive plural)
косты́льный (adjective relational)
косты́ль (nominative singular)
костыли́ (nominative plural)
костыля́ (genitive singular)
костыле́й (genitive plural)
костылю́ (dative singular)
костыля́м (dative plural)
косты́ль (accusative singular)
костыли́ (accusative plural)
костылём (instrumental singular)
костыля́ми (instrumental plural)
костыле́ (prepositional singular)
костыля́х (plural prepositional)

Ru-костыль.ogg

кость (kostʹ, “bone”) + -ы́ль (-ýlʹ). Compare Polish kostur, koścień.
For the word formation with suffix -ы́ль (-ýlʹ) compare горбы́ль (gorbýlʹ) from горб (gorb). Also compare моты́ль (motýlʹ), ковы́ль (kovýlʹ).

(programming slang) kludge, workaround, hack


Programmierung

de-noun

Programmierung f (genitive Programmierung, plural Programmierungen)

Programmierung (genitive)
Programmierungen (plural)
Programmierung (nominative singular)
Programmierungen (definite nominative plural)
Programmierung (genitive singular)
Programmierungen (definite genitive plural)
Programmierung (dative singular)
Programmierungen (dative definite plural)
Programmierung (accusative singular)
Programmierungen (accusative definite plural)

/pʁoɡʁaˈmiːʁʊŋ/

(uncountable) programming (the act of programming)

(countable) programming, program (of a device)


repetitie

nl-noun

repetitie f (plural repetities, diminutive repetitietje n)

repetities (plural)
repetitietje (diminutive neuter)

→ Indonesian: repetisi

→ Indonesian: ulangan (calque)


variadic

/vɛəɹiˈædɪk/

C's printf is one of the most widely used variadic functions.

There are some functions and predicates which we tend to think of as being able to take any number of parameters – of being of variable arity or variadic.

1983, Alan Bundy, The Computer Modelling of Mathematical Reasoning, Academic Press, page 48:

The variadic functions that increase the valence of the input relation through the addition of a circumstance to the set of its argument-roles can be represented by means of an operator (or rather, a family of operators) ‘Circ’.

2004, François Récanati, Literal Meaning, Cambridge University Press, →ISBN, page 109:

However, the real max procedure of Scheme is a variadic procedure, which means that it accepts any positive number of arguments: ¶ (max 5 1 3 8 9 7 2 6 4) => 9

2006, Nils M. Holm, Sketchy LISP: An Introduction to Functional Programming in Scheme, 2nd edition, Lulu.com, →ISBN, page 53:

(programming, mathematics, linguistics) Taking a variable number of arguments; especially, taking arbitrarily many arguments.

prinimajuščij peremennoje čisló parametrov

принимающий переменное число́ параметров

each variadic argument

(programming) Belonging to a variadic function.


variadic

/vɛəɹiˈædɪk/

PHP 5.6 introduced variadics that explicitly accept a variable number of parameters.

2017, Andrew Beak, PHP 7 Zend Certification Study Guide, page 44:

(programming) A function that takes a variable number of arguments.


metacircular

en-adj

metacircular (comparative more metacircular, superlative most metacircular)

more metacircular (comparative)
most metacircular (superlative)

(computing, programming) Exhibiting metacircularity.


minify

en-verb

minify (third-person singular simple present minifies, present participle minifying, simple past and past participle minified)

minifies (present singular third-person)
minifying (participle present)
minified (participle past)
minified (past)

LL-Q1860 (eng)-Flame, not lame-minify.wav

When code is minified, all comments are removed, as well as unneeded whitespace characters (space, newline, and tab).

2008, Steve Souders, High Performance Web Sites: Essential Knowledge for Front-End Engineers,, O'Reilly, page 69:

(programming) To remove white space and unnecessary characters from source code in order to reduce its size.


read-eval-print loop

en-noun

read–eval–print loop (plural read-eval-print loops)

read–eval–print loop (canonical)
read-eval-print loops (plural)

It is easier to experiment in languages that provide a read-eval-print loop.

(programming) An interactive programming language interpreter.


mark and sweep

(programming) A form of garbage collection in which every accessible object in memory is flagged, leaving unflagged only those that are no longer reachable and can thus be discarded.


ríomhchlárú

head

ríomhchlárú m (genitive singular ríomhchláraithe)

ríomhchláraithe (genitive singular)
ríomhchlárú (indefinite nominative singular)
a ríomhchlárú (indefinite singular vocative)
ríomhchláraithe (genitive indefinite singular)
ríomhchlárú (dative indefinite singular)
an ríomhchlárú (definite nominative singular)
an ríomhchláraithe (definite genitive singular)
leis an ríomhchlárú (dative definite singular)
don ríomhchlárú (dative definite singular)

ríomh- (“computer”) + clárú (“programming”)


unswizzle

en-verb

unswizzle (third-person singular simple present unswizzles, present participle unswizzling, simple past and past participle unswizzled)

unswizzles (present singular third-person)
unswizzling (participle present)
unswizzled (participle past)
unswizzled (past)

(programming, transitive) To convert memory-dependent pointers to portable symbols or positions during serialization.


LGTM

tlb

(informal, originally programming jargon)

Said to have originated within Google, early 2000s, originally to give positive feedback on other people's work in a code review.

The primary end goal of a code review is to get another engineer to consent to the change, which we denote by tagging the change as “looks good to me” (LGTM). We use this LGTM as a necessary permissions “bit” (combined with the other bits noted below) to allow the change to be committed.

2020, Titus Winters, Tom Manshreck, Hyrum Wright, “Code Review”, in Software Engineering at Google […] , O'Reilly, →ISBN:


waker

From Middle English wakere, equivalent to wake + -er. Compare West Frisian wekker (“alarm clock”, literally “waker”), Dutch wekker, German Wecker.

cog

(programming) In the Rust programming language, a handle that "wakes up" a task by notifying its executor that it is ready to be run.


tiomsaigh

head

tiomsaigh (present analytic tiomsaíonn, future analytic tiomsóidh, verbal noun tiomsú, past participle tiomsaithe)

tiomsaíonn (analytic present)
tiomsóidh (analytic future)
tiomsú (noun-from-verb)
tiomsaithe (participle past)
tiomsú (noun-from-verb)
tiomsaithe (participle past)
tiomsaím (first-person indicative present singular)
tiomsaíonn tú (indicative present second-person singular)
tiomsaír (indicative present second-person singular)
tiomsaíonn sé (indicative present singular third-person)
sí (indicative present singular third-person)
tiomsaímid (first-person indicative plural present)
tiomsaíonn muid (first-person indicative plural present)
tiomsaíonn sibh (indicative plural present second-person)
tiomsaíonn siad (indicative plural present third-person)
tiomsaíd (indicative plural present third-person)
a thiomsaíonn (indicative present relative)
a thiomsaíos (indicative present relative)
a dtiomsaíonn (indicative present relative)
tiomsaítear (autonomous indicative present)
thiomsaigh mé (first-person indicative past singular)
thiomsaíos (first-person indicative past singular)
thiomsaigh tú (indicative past second-person singular)
thiomsaís (indicative past second-person singular)
thiomsaigh sé (indicative past singular third-person)
sí (indicative past singular third-person)
thiomsaíomar (first-person indicative past plural)
thiomsaigh muid (first-person indicative past plural)
thiomsaigh sibh (indicative past plural second-person)
thiomsaíobhair (indicative past plural second-person)
thiomsaigh siad (indicative past plural third-person)
thiomsaíodar (indicative past plural third-person)
a thiomsaigh (indicative past relative)
ar thiomsaigh (indicative past relative)
tiomsaíodh (autonomous indicative past)
thiomsaínn (first-person habitual indicative past singular)
dtiomsaínn‡‡ (first-person habitual indicative past singular)
thiomsaíteá (habitual indicative past second-person singular)
dtiomsaíteá‡‡ (habitual indicative past second-person singular)
thiomsaíodh sé (habitual indicative past singular third-person)
sí (habitual indicative past singular third-person)
dtiomsaíodh sé (habitual indicative past singular third-person)
sí‡‡ (habitual indicative past singular third-person)
thiomsaímis (first-person habitual indicative past plural)
thiomsaíodh muid (first-person habitual indicative past plural)
dtiomsaímis‡‡ (first-person habitual indicative past plural)
dtiomsaíodh muid‡‡ (first-person habitual indicative past plural)
thiomsaíodh sibh (habitual indicative past plural second-person)
dtiomsaíodh sibh‡‡ (habitual indicative past plural second-person)
thiomsaídís (habitual indicative past plural third-person)
thiomsaíodh siad (habitual indicative past plural third-person)
dtiomsaídís‡‡ (habitual indicative past plural third-person)
dtiomsaíodh siad‡‡ (habitual indicative past plural third-person)
a thiomsaíodh (habitual indicative past relative)
a dtiomsaíodh (habitual indicative past relative)
thiomsaítí (autonomous habitual indicative past)
dtiomsaítí‡‡ (autonomous habitual indicative past)
tiomsóidh mé (first-person future indicative singular)
tiomsód (first-person future indicative singular)
tiomsóchaidh mé (first-person future indicative singular)
tiomsóidh tú (future indicative second-person singular)
tiomsóir (future indicative second-person singular)
tiomsóchaidh tú (future indicative second-person singular)
tiomsóidh sé (future indicative singular third-person)
sí (future indicative singular third-person)
tiomsóchaidh sé (future indicative singular third-person)
tiomsóimid (first-person future indicative plural)
tiomsóidh muid (first-person future indicative plural)
tiomsóchaimid (first-person future indicative plural)
tiomsóchaidh muid (first-person future indicative plural)
tiomsóidh sibh (future indicative plural second-person)
tiomsóchaidh sibh (future indicative plural second-person)
tiomsóidh siad (future indicative plural third-person)
tiomsóid (future indicative plural third-person)
tiomsóchaidh siad (future indicative plural third-person)
a thiomsóidh (future indicative relative)
a thiomsós (future indicative relative)
a thiomsóchaidh (future indicative relative)
a thiomsóchas (future indicative relative)
a dtiomsóidh (future indicative relative)
a dtiomsóchaidh (future indicative relative)
tiomsófar (autonomous future indicative)
tiomsóchar (autonomous future indicative)
thiomsóinn (conditional first-person singular)
thiomsóchainn (conditional first-person singular)
dtiomsóinn‡‡ (conditional first-person singular)
dtiomsóchainn^†‡‡ (conditional first-person singular)
thiomsófá (conditional second-person singular)
thiomsóchthá (conditional second-person singular)
dtiomsófá‡‡ (conditional second-person singular)
dtiomsóchthá^†‡‡ (conditional second-person singular)
thiomsódh sé (conditional singular third-person)
sí (conditional singular third-person)
thiomsóchadh sé (conditional singular third-person)
dtiomsódh sé (conditional singular third-person)
sí‡‡ (conditional singular third-person)
dtiomsóchadh sé (conditional singular third-person)
sí^†‡‡ (conditional singular third-person)
thiomsóimis (conditional first-person plural)
thiomsódh muid (conditional first-person plural)
thiomsóchaimis (conditional first-person plural)
thiomsóchadh muid (conditional first-person plural)
dtiomsóimis‡‡ (conditional first-person plural)
dtiomsódh muid‡‡ (conditional first-person plural)
dtiomsóchaimis^†‡‡ (conditional first-person plural)
dtiomsóchadh muid^†‡‡ (conditional first-person plural)
thiomsódh sibh (conditional plural second-person)
thiomsóchadh sibh (conditional plural second-person)
dtiomsódh sibh‡‡ (conditional plural second-person)
dtiomsóchadh sibh^†‡‡ (conditional plural second-person)
thiomsóidís (conditional plural third-person)
thiomsódh siad (conditional plural third-person)
thiomsóchadh siad (conditional plural third-person)
dtiomsóidís‡‡ (conditional plural third-person)
dtiomsódh siad‡‡ (conditional plural third-person)
dtiomsóchadh siad^†‡‡ (conditional plural third-person)
a thiomsódh (conditional relative)
a thiomsóchadh (conditional relative)
a dtiomsódh (conditional relative)
a dtiomsóchadh (conditional relative)
thiomsófaí (autonomous conditional)
thiomsóchthaí (autonomous conditional)
dtiomsófaí‡‡ (autonomous conditional)
dtiomsóchthaí^†‡‡ (autonomous conditional)
go dtiomsaí mé (first-person present singular subjunctive)
go dtiomsaíod (first-person present singular subjunctive)
go dtiomsaí tú (present second-person singular subjunctive)
go dtiomsaír (present second-person singular subjunctive)
go dtiomsaí sé (present singular subjunctive third-person)
sí (present singular subjunctive third-person)
go dtiomsaímid (first-person plural present subjunctive)
go dtiomsaí muid (first-person plural present subjunctive)
go dtiomsaí sibh (plural present second-person subjunctive)
go dtiomsaí siad (plural present subjunctive third-person)
go dtiomsaíd (plural present subjunctive third-person)
go dtiomsaítear (autonomous present subjunctive)
dá dtiomsaínn (first-person past singular subjunctive)
dá dtiomsaíteá (past second-person singular subjunctive)
dá dtiomsaíodh sé (past singular subjunctive third-person)
sí (past singular subjunctive third-person)
dá dtiomsaímis (first-person past plural subjunctive)
dá dtiomsaíodh muid (first-person past plural subjunctive)
dá dtiomsaíodh sibh (past plural second-person subjunctive)
dá dtiomsaídís (past plural subjunctive third-person)
dá dtiomsaíodh siad (past plural subjunctive third-person)
dá dtiomsaítí (autonomous past subjunctive)
tiomsaím (first-person imperative singular)
tiomsaigh (imperative second-person singular)
tiomsaíodh sé (imperative singular third-person)
sí (imperative singular third-person)
tiomsaímis (first-person imperative plural)
tiomsaígí (imperative plural second-person)
tiomsaídh (imperative plural second-person)
tiomsaídís (imperative plural third-person)
tiomsaítear (autonomous imperative)
tiomsaigh
thiomsaigh
dtiomsaigh


compileren

compileren (infinitive)
compileren (gerund neuter)
compileer (first-person present singular)
compileerde (first-person past singular)
compileert (present second-person singular)
compileer (present second-person singular)
compileerde (past second-person singular)
compileert (formal present second-person singular)
compileerde (formal past second-person singular)
compileert (Flanders colloquial present second-person singular)
compileert (archaic formal majestic present second-person singular)
compileerde (Flanders colloquial past second-person singular)
compileerde (archaic formal majestic past second-person singular)
compileert (present singular third-person)
compileerde (past singular third-person)
compileren (plural present)
compileerden (past plural)
compilere (archaic present singular subjunctive)
compileerde (archaic past singular subjunctive)
compileren (archaic plural present subjunctive)
compileerden (archaic past plural subjunctive)
compileer (imperative present singular)
compileert (archaic imperative plural present)
compilerend (participle present)
gecompileerd (participle past)

From Middle Dutch compileren, from Old French compiler, from Latin compīlō.


vtable

Shortening of virtual method table or virtual function table.

This solution allows the Command executor to iterate through a collection of unrelated objects with no vtables and pick out the right method for each one.

Note that nonvirtual functions do not appear in a vtable.

2003, John C. Mitchell, Concepts in programming languages:

The most likely result will be a crash when the code tries to use a vtable entry that contains random garbage.

2003, Steve Heller, C++: a dialogue: programming with the C++ standard library:

(programming) A table of memory pointers to different implementations of a virtual function.


awaiter

From Middle English awaytur; equivalent to await + -er.

(programming) An object that waits for the completion of an asynchronous task.


upcall

(programming) A call from a lower-level subsystem, such as a kernel or framework, to a higher-level subsystem, such as user code.


chuỗi

𠁻, 𦀵, 𥣽, 𫡍, 𫡎

vi-noun

𠁻, 𦀵, 𥣽, 𫡍, 𫡎


SLOC

(programming) Initialism of source lines of code.


new up

en-verb

new up (third-person singular simple present news up, present participle newing up, simple past and past participle newed up)

news up (present singular third-person)
newing up (participle present)
newed up (participle past)
newed up (past)

The keyword new creates an object in C++ and derived languages.

If an exception occurs trying to new up bar1 or bar2, the TFoo part of the object won't have changed […]

So you just new up the object you want and once its internal reference count drops to 0, the language deletes it (during a free time as a background thread).

2003, Jonathan Hoyle, “Pointers?”, in comp.lang.basic.realbasic (Usenet):

(programming, informal, transitive) To create (an object) by calling its constructor.


metamethod

en-noun

metamethod (countable and uncountable, plural metamethods)

(programming, Lua) A method belonging to a metatable.


metatable

(programming, Lua) A table (of key-value pairs) associated with another object, which uses the functions (or other data) it contains to define the behaviour of that object under certain conditions.


erklære

head

erklære (imperative erklær, infinitive at erklære, present tense erklærer, past tense erklærede, perfect tense har erklæret)

erklær (imperative)
at erklære (infinitive)
erklærer (present)
erklærede (past)
har erklæret (perfect)
erklærer (active present)
erklæres (passive present)
erklærede (active past)
erklæredes (passive past)
erklære (active infinitive)
erklæres (infinitive passive)
erklær (active imperative)
erklærende (participle present)
erklæret (participle past)
auxiliary verb have (participle past)
erklæren (gerund participle)

[æɐ̯ˈkʰlɛːˀɐ]

Nogle computersprog kræver, at du erklærer en variabel, før du bruger den. JavaScript indeholder nøgleordet var, der kan bruges til at erklære en variabel.

2004, JavaScript-bogen (PB), Libris Media A/S, →ISBN, page 50:

Some computer language require you to declare a variable before using it. JavaScript contains the keyword var, which can be used to declare a variable.

Du kan også erklære et array uden at specificere et antal pladser på forhånd.

2007, Datalogi C Stx, Hf, Htx, Hhx, Gyldendal Uddannelse, →ISBN, page 69:

You can also declare an array without specifying a number of slots in advance.

Brug af globale variabler er praktisk, da du kun skal erklære dem en gang i en fælles liste.

2019, Tom Mejer Antonsen, PLC styring med Structured Text (ST): IEC 61131-3 og best practice ST-programmering, BoD – Books on Demand, →ISBN, page 115:

The use of global variables is practical, as you only have to declare them once in a shared list.

(programming) to declare; to set aside a portion of memory for


declarator

(programming) A construct in source code that declares something, such as a variable.


eiginleiki

is-noun

eiginleiki m (genitive singular eiginleika, nominative plural eiginleikar)

eiginleika (genitive singular)
eiginleikar (nominative plural)
eiginleiki (indefinite nominative singular)
eiginleikinn (definite nominative singular)
eiginleikar (indefinite nominative plural)
eiginleikarnir (definite nominative plural)
eiginleika (accusative indefinite singular)
eiginleikann (accusative definite singular)
eiginleika (accusative indefinite plural)
eiginleikana (accusative definite plural)
eiginleika (dative indefinite singular)
eiginleikanum (dative definite singular)
eiginleikum (dative indefinite plural)
eiginleikunum (dative definite plural)
eiginleika (genitive indefinite singular)
eiginleikans (definite genitive singular)
eiginleika (genitive indefinite plural)
eiginleikanna (definite genitive plural)

(computing, programming, object-oriented programming) property (data value belonging to each object in a class)


όρισμα

head

όρισμα • (órisma) n (plural ορίσματα)

el-noun

όρισμα • (órisma) n (plural ορίσματα)

órisma (romanization)
ορίσματα (plural)
όρισμα (nominative singular)
ορίσματα (nominative plural)
ορίσματος (genitive singular)
ορισμάτων (genitive plural)
όρισμα (accusative singular)
ορίσματα (accusative plural)
όρισμα (singular vocative)
ορίσματα (plural vocative)

(mathematics, programming) argument (independent variable, function argument)


teanga ríomhchlárúcháin

head

teanga ríomhchlárúcháin f (genitive singular teanga ríomhchlárúcháin, nominative plural teangacha ríomhchlárúcháin)

teanga ríomhchlárúcháin (genitive singular)
teangacha ríomhchlárúcháin (nominative plural)
teanga ríomhchlárúcháin
theanga ríomhchlárúcháin
dteanga ríomhchlárúcháin


ríomhchlárúchán

ríomhchlárúchán m (genitive singular ríomhchlárúcháin)

ríomhchlárúcháin (genitive singular)
ríomhchlárúchán (indefinite nominative singular)
a ríomhchlárúcháin (indefinite singular vocative)
ríomhchlárúcháin (genitive indefinite singular)
ríomhchlárúchán (dative indefinite singular)
an ríomhchlárúchán (definite nominative singular)
an ríomhchlárúcháin (definite genitive singular)
leis an ríomhchlárúchán (dative definite singular)
don ríomhchlárúchán (dative definite singular)

From ríomhchlárú (“computer programming”) + -achán.

af

computer programming
computer programming


pythonic

(programming) Alternative letter-case form of Pythonic (“using the idioms of the Python programming language”).


undefine

en-verb

undefine (third-person singular simple present undefines, present participle undefining, simple past and past participle undefined)

undefines (present singular third-person)
undefining (participle present)
undefined (participle past)
undefined (past)

(programming, transitive) To remove the definition of; to return to an undefined state.


tiomsaitheoir

head

tiomsaitheoir m (genitive singular tiomsaitheora, nominative plural tiomsaitheoirí)

tiomsaitheora (genitive singular)
tiomsaitheoirí (nominative plural)
tiomsaitheoir (indefinite nominative singular)
tiomsaitheoirí (indefinite nominative plural)
a thiomsaitheoir (indefinite singular vocative)
a thiomsaitheoirí (indefinite plural vocative)
tiomsaitheora (genitive indefinite singular)
tiomsaitheoirí (genitive indefinite plural)
tiomsaitheoir (dative indefinite singular)
tiomsaitheoirí (dative indefinite plural)
an tiomsaitheoir (definite nominative singular)
na tiomsaitheoirí (definite nominative plural)
an tiomsaitheora (definite genitive singular)
na dtiomsaitheoirí (definite genitive plural)
leis an tiomsaitheoir (dative definite singular)
don tiomsaitheoir (dative definite singular)
leis na tiomsaitheoirí (dative definite plural)
tiomsaitheoir
thiomsaitheoir
dtiomsaitheoir


Ява

Я́ва (canonical)
Я́вы (genitive)
Я́ва (nominative singular)
Jáva (nominative singular)
Я́вы (genitive singular)
Я́ве (dative singular)
Я́ву (accusative singular)
Я́вой (instrumental singular)
Я́вою (instrumental singular)
Я́ве (prepositional singular)
Джава (alternative)
жа́ба (alternative)

(programming) Java (programming language)


Klassenpfad

de-noun

Klassenpfad m (strong, genitive Klassenpfades or Klassenpfads, plural Klassenpfade)

Klassenpfades (genitive)
Klassenpfads (genitive)
Klassenpfade (plural)
Klassenpfad (nominative singular)
Klassenpfade (definite nominative plural)
Klassenpfades (genitive singular)
Klassenpfads (genitive singular)
Klassenpfade (definite genitive plural)
Klassenpfad (dative singular)
Klassenpfade (dative singular)
Klassenpfaden (dative definite plural)
Klassenpfad (accusative singular)
Klassenpfade (accusative definite plural)


Binärkompatibilität

Binärkompatibilität f (genitive Binärkompatibilität, no plural)

Binärkompatibilität (genitive)
Binärkompatibilität (nominative singular)
Binärkompatibilität (genitive singular)
Binärkompatibilität (dative singular)
Binärkompatibilität (accusative singular)

binär (“binary”) + Kompatibilität (“compatibility”)

compound

binary compatibility
binary compatibility

binary code compatibility
binary code compatibility

(computing) binary compatibility, binary code compatibility


superglobal

LL-Q1860 (eng)-Flame, not lame-superglobal.wav

(computing, programming, in the PHP programming language) Any of a set of special predefined variables that can be accessed at any point in a program without the need to be explicitly declared as global.


blort

en-noun

blort (countable and uncountable, plural blorts)

Onomatopoetic; in sense 1, also blend of blow + snort.

metasyntactic variable
metasyntactic variable#English

(programming, uncountable) A metasyntactic variable similar to foo and bar.


Cheshire cat

the Cheshire cat (canonical)
Cheshire cats (plural)

/ˌtʃɛʃə ˈkat/

/ˌtʃɛʃɚ ˈkæt/

Term attested since at least the 1780s in the expression grin like a Cheshire cat. The reason why Cheshire was combined with cat is disputed: see here for more information.

the Cheshire cat idiom

the Cheshire cat technique

(programming, attributive) A technique that involves hiding a class's data behind a pointer, so that the code remains binary-compatible even after future changes to members and functionality.


оператор

uk-noun

((опера́тор<pr>,опера́тор<>))

опера́торський

опера́тор • (operátor) m pers or m inan (genitive опера́тора, nominative plural опера́тори, genitive plural опера́торів, feminine опера́торка, relational adjective опера́торський)

опера́тор (canonical)
operátor (romanization)
опера́тора (genitive)
опера́тори (nominative plural)
опера́торів (genitive plural)
опера́торка (feminine)
опера́торський (adjective relational)
опера́тор (nominative singular)
опера́тори (nominative plural)
опера́тора (genitive singular)
опера́торів (genitive plural)
опера́торові (dative singular)
опера́тору (dative singular)
опера́торам (dative plural)
опера́тора (accusative personal singular)
опера́тор (accusative inanimate singular)
опера́торів (accusative personal plural)
опера́тори (accusative inanimate plural)
опера́тором (instrumental singular)
опера́торами (instrumental plural)
опера́торові (locative singular)
опера́торі (locative singular)
опера́торах (locative plural)
опера́торе (singular vocative)
опера́тори (plural vocative)

Uk-оператор.ogg

(inanimate, programming) operator (a symbol that represents a construct in a programming language and differs from a normal function in its syntax)


JNI

(programming) Initialism of Java Native Interface.


MMAPI

(programming) Initialism of Mobile Media API.


type safety

(programming, software compilation) The extent to which a programming language is type-safe.

tyyppiturvallisuus

the extent to which a programming language is type-safe


programlingvo

eo-head

programlingvo (accusative singular programlingvon, plural programlingvoj, accusative plural programlingvojn)

programlingvon (accusative singular)
programlingvoj (plural)
programlingvojn (accusative plural)

From programo (“program”) + lingvo (“language”).


Hallo-Welt-Programm

de-noun

Hallo-Welt-Programm n (strong, genitive Hallo-Welt-Programmes or Hallo-Welt-Programms, plural Hallo-Welt-Programme)

Hallo-Welt-Programmes (genitive)
Hallo-Welt-Programms (genitive)
Hallo-Welt-Programme (plural)

hallo (“hello”) + Welt (“world”) + Programm (“program”)


deoptimize

en-verb

deoptimize (third-person singular simple present deoptimizes, present participle deoptimizing, simple past and past participle deoptimized)

deoptimizes (present singular third-person)
deoptimizing (participle present)
deoptimized (participle past)
deoptimized (past)

(transitive, programming) To reverse a previous optimization, typically when the assumptions that made it valid prove to be incorrect.


constness

From const (“a keyword for constant in the C programming language and its derivatives”) + -ness.

affix

a keyword for <i class="Latn mention" lang="en">constant</i> in the C programming language and its derivatives

If you want to change a class member inside a const member function, the traditional approach is to cast away constness by saying (X*)this.

1995, Embedded Systems Programming, volume 8, page 180:

(programming) The declaration of variables or objects as immutable.


stackless

(programming) Without the use of a stack (last-in-first-out data structure).


(programming) Increment by 1 (in certain programming languages such as C and Java).

(programming) Concatenation (as an approximation of the mathematical symbol ⧺ in certain programming languages such as Haskell).


hyperslice

(computing, programming) A set of concerns in aspect-oriented programming.


PAT

en-noun

PAT (countable and uncountable, plural PATs)

Protocols are abstract as they are, but with PATs, you’re making your protocols generic, which makes your code even more abstract and exponentially complex.

2019, Tjeerd in 't Veen, chapter 8, in Swift in Depth, Manning, →ISBN:

(programming) Initialism of protocol associated type.


rule of three

the rule of three (canonical)
the Rule of Three (alternative)

(programming) A rule of thumb in the C++ programming language, stating that any class that defines a destructor, a copy constructor, or a copy assignment operator should define all three of them.


lasagna code

Modeled after spaghetti code, and based on the layered construction of lasagna; coined by Joe Celko in 1982.

(programming, rare) Computer program code characterized by several well-defined and separable layers forming a hierarchy of subsystems.


domain-specific language

domain-specific language (plural domain-specific languages)

(programming) A programming/specification language that is dedicated to a particular problem domain, a particular problem representation/solution technique.

langage dédié

language dedicated to a particular problem domain


オーバーライド

ja-noun

オーバーライド • (ōbāraido)


cdr

Acronym of contents of the decrement part of register number. Note that it was based on original hardware and has no meaning today.

acronym

The elements of a list are the successive cars along the "cdr chain." That is, the elements are the car, the car of the cdr, the car of the cdr of the cdr, etc.

2000, Matt Kaufmann, Panagiotis Manolios, J Strother Moore, Computer-aided reasoning: an approach:

(programming) The second part of a cons in Lisp. The remainder of a list when the first element is removed.


cadr

If we let x denote the tree (1 2 3), then the car of x is 1, the cdr of x is (2 3), the cadr of x is 2, the caddr of x is 3, and the cdddr of x is nil.

2000, Matt Kaufmann, Panagiotis Manolios, J. Strother Moore, Computer-Aided Reasoning: An Approach:

(programming) Car of the cdr in Lisp. The second element in a list.


caddr

Contraction of car of the cdr of the cdr.

Following the SEL in the control list are two elements (the cadr and caddr of the C list), both of which are themselves lists of instructions.

1991, Peter M. Kogge, The Architecture of Symbolic Computers, page 156:

For example, in a procedure that manipulates a list data stream, we might know that the mode of the car of the list (that is the current message) is the same mode as the cadr (second message), caddr (third message), etc.

1994, Evan Tick, Giancarlo Succi, Implementations of Logic Programming Systems, →ISBN, page 239:

In effect, lazy evaluation would force things to happen in the proper order: The car of output is the first prompt. The cadr of output is the first square, a value that requires evaluation of the car of input. The caddr of output is the second prompt.

2004, Scott, Programming Principles Of Mulltimedia Systems, →ISBN, page 608:

(programming) Car of the cdr of the cdr in Lisp. The third element in a list.


iterátor

iterátor (nominative singular)
iterátory (nominative plural)
iterátoru (genitive singular)
iterátorů (genitive plural)
iterátoru (dative singular)
iterátorům (dative plural)
iterátor (accusative singular)
iterátory (accusative plural)
iterátore (singular vocative)
iterátory (plural vocative)
iterátoru (locative singular)
iterátorech (locative plural)
iterátorem (instrumental singular)
iterátory (instrumental plural)


llibreria

[ʎi.βɾəˈɾi.ə]

(proscribed, programming) library (collection of software routines)


ptr

1993, lbunch, “C++ dynamic array of ptrs”, in comp.sys.mac.oop.macapp3 (Usenet):

1998, Malcolm Watts, “Passing memory ptrs between lib and C++ code ?”, in comp.os.ms-windows.programmer.memory (Usenet):


upvalue

(computing, programming) A free variable that has been bound (closed over) with a closure.


double precision

(programming) A number storage format that uses two adjacent locations in memory, allowing for greater precision in the values stored.


tickable

A tick is an event that occurs for every N low-level tickable statements executed by the parser within the declare block.

2017, Branko Ajzele, Mastering PHP 7, page 143:

(programming, PHP) Of a program instruction: counted for the purpose of generating periodic signals every few instructions.


JAXB

(programming) Initialism of Jakarta XML Binding.

(programming, dated) Initialism of Java Architecture for XML Binding.


MinGW

(programming) Acronym of Minimalist GNU for Windows.


程序員

/ʈ͡ʂʰɤŋ³⁵ ɕy⁵¹ ɥɛn³⁵/

ㄔㄥˊ ㄒㄩˋ ㄩㄢˊㄦ

/ʈ͡ʂʰɤŋ³⁵ ɕy⁵¹ ɥɑɻ³⁵/

/t͡sʰɪŋ²¹ t͡sɵy̯²² jyːn²¹/

/tʰiɪŋ²⁴⁻²² su²²⁻²¹ uan²⁴/

/tʰiɪŋ²³⁻³³ su³³⁻²¹ uan²³/

/tʰiɪŋ²⁴⁻¹¹ su³³⁻¹¹ uan²⁴/

/tʰiɪŋ¹³⁻²² si²²⁻²¹ uan¹³/

/tʰiɪŋ²⁴⁻²² sɯ²² uan²⁴/

/ʈ͡ʂʰɤŋ³⁵ ɕy⁵¹ ɥɛn³⁵/

/ʈ͡ʂʰɤŋ³⁵ ɕy⁵¹ ɥɑɻ³⁵/

/t͡sʰɪŋ²¹ t͡sɵy̯²² jyːn²¹/

/tʰiɪŋ²⁴⁻²² su²²⁻²¹ uan²⁴/

/tʰiɪŋ²³⁻³³ su³³⁻²¹ uan²³/

/tʰiɪŋ²⁴⁻¹¹ su³³⁻¹¹ uan²⁴/

/tʰiɪŋ¹³⁻²² si²²⁻²¹ uan¹³/

/tʰiɪŋ²⁴⁻²² sɯ²² uan²⁴/


analyst programmer

en-noun

analyst programmer (plural analyst programmers)

A computer programmer who also does the work of a systems analyst.


индус

ru-noun+

инду́с • (indús) m anim (genitive инду́са, nominative plural инду́сы, genitive plural инду́сов, feminine инду́ска, relational adjective инду́сский)

инду́с (canonical)
indús (romanization)
инду́са (genitive)
инду́сы (nominative plural)
инду́сов (genitive plural)
инду́ска (feminine)
инду́сский (adjective relational)
инду́с (nominative singular)
инду́сы (nominative plural)
инду́са (genitive singular)
инду́сов (genitive plural)
инду́су (dative singular)
инду́сам (dative plural)
инду́са (accusative singular)
инду́сов (accusative plural)
инду́сом (instrumental singular)
инду́сами (instrumental plural)
инду́се (prepositional singular)
инду́сах (plural prepositional)

(programming slang, derogatory, offensive) junior coder, code monkey (an inexperienced or unqualified software developer)


antibugging

They were convinced that the error-checking and antibugging that I was suggesting would far exceed the capacity of their machine.

1975, Edward Yourdon, Techniques of program structure and design:

(programming) The strategy of writing code so as to minimise the possibility of error.


VHLL

(programming) Initialism of very high-level language.


merkintäkieli

merkintäkieli (nominative singular)
merkintäkielet (nominative plural)
merkintäkieli (accusative nominative singular)
merkintäkielet (accusative nominative plural)
merkintäkielen (accusative genitive singular)
merkintäkielet (accusative genitive plural)
merkintäkielen (genitive singular)
merkintäkielten (genitive plural)
merkintäkielien (genitive plural)
merkintäkieltä (partitive singular)
merkintäkieliä (partitive plural)
merkintäkielessä (inessive singular)
merkintäkielissä (inessive plural)
merkintäkielestä (elative singular)
merkintäkielistä (elative plural)
merkintäkieleen (illative singular)
merkintäkieliin (illative plural)
merkintäkielellä (adessive singular)
merkintäkielillä (adessive plural)
merkintäkieleltä (ablative singular)
merkintäkieliltä (ablative plural)
merkintäkielelle (allative singular)
merkintäkielille (allative plural)
merkintäkielenä (essive singular)
merkintäkielinä (essive plural)
merkintäkieleksi (singular translative)
merkintäkieliksi (plural translative)
merkintäkielettä (abessive singular)
merkintäkielittä (abessive plural)
merkintäkielin (instructive plural)
See the possessive forms below. (comitative)
merkintäkieleni (nominative singular)
merkintäkieleni (nominative plural)
merkintäkieleni (accusative nominative singular)
merkintäkieleni (accusative nominative plural)
merkintäkieleni (accusative genitive singular)
merkintäkieleni (accusative genitive plural)
merkintäkieleni (genitive singular)
merkintäkielteni (genitive plural)
merkintäkielieni (genitive plural)
merkintäkieltäni (partitive singular)
merkintäkieliäni (partitive plural)
merkintäkielessäni (inessive singular)
merkintäkielissäni (inessive plural)
merkintäkielestäni (elative singular)
merkintäkielistäni (elative plural)
merkintäkieleeni (illative singular)
merkintäkieliini (illative plural)
merkintäkielelläni (adessive singular)
merkintäkielilläni (adessive plural)
merkintäkieleltäni (ablative singular)
merkintäkieliltäni (ablative plural)
merkintäkielelleni (allative singular)
merkintäkielilleni (allative plural)
merkintäkielenäni (essive singular)
merkintäkielinäni (essive plural)
merkintäkielekseni (singular translative)
merkintäkielikseni (plural translative)
merkintäkielettäni (abessive singular)
merkintäkielittäni (abessive plural)
merkintäkielineni (comitative plural)
merkintäkielesi (nominative singular)
merkintäkielesi (nominative plural)
merkintäkielesi (accusative nominative singular)
merkintäkielesi (accusative nominative plural)
merkintäkielesi (accusative genitive singular)
merkintäkielesi (accusative genitive plural)
merkintäkielesi (genitive singular)
merkintäkieltesi (genitive plural)
merkintäkieliesi (genitive plural)
merkintäkieltäsi (partitive singular)
merkintäkieliäsi (partitive plural)
merkintäkielessäsi (inessive singular)
merkintäkielissäsi (inessive plural)
merkintäkielestäsi (elative singular)
merkintäkielistäsi (elative plural)
merkintäkieleesi (illative singular)
merkintäkieliisi (illative plural)
merkintäkielelläsi (adessive singular)
merkintäkielilläsi (adessive plural)
merkintäkieleltäsi (ablative singular)
merkintäkieliltäsi (ablative plural)
merkintäkielellesi (allative singular)
merkintäkielillesi (allative plural)
merkintäkielenäsi (essive singular)
merkintäkielinäsi (essive plural)
merkintäkieleksesi (singular translative)
merkintäkieliksesi (plural translative)
merkintäkielettäsi (abessive singular)
merkintäkielittäsi (abessive plural)
merkintäkielinesi (comitative plural)
merkintäkielemme (nominative singular)
merkintäkielemme (nominative plural)
merkintäkielemme (accusative nominative singular)
merkintäkielemme (accusative nominative plural)
merkintäkielemme (accusative genitive singular)
merkintäkielemme (accusative genitive plural)
merkintäkielemme (genitive singular)
merkintäkieltemme (genitive plural)
merkintäkieliemme (genitive plural)
merkintäkieltämme (partitive singular)
merkintäkieliämme (partitive plural)
merkintäkielessämme (inessive singular)
merkintäkielissämme (inessive plural)
merkintäkielestämme (elative singular)
merkintäkielistämme (elative plural)
merkintäkieleemme (illative singular)
merkintäkieliimme (illative plural)
merkintäkielellämme (adessive singular)
merkintäkielillämme (adessive plural)
merkintäkieleltämme (ablative singular)
merkintäkieliltämme (ablative plural)
merkintäkielellemme (allative singular)
merkintäkielillemme (allative plural)
merkintäkielenämme (essive singular)
merkintäkielinämme (essive plural)
merkintäkieleksemme (singular translative)
merkintäkieliksemme (plural translative)
merkintäkielettämme (abessive singular)
merkintäkielittämme (abessive plural)
merkintäkielinemme (comitative plural)
merkintäkielenne (nominative singular)
merkintäkielenne (nominative plural)
merkintäkielenne (accusative nominative singular)
merkintäkielenne (accusative nominative plural)
merkintäkielenne (accusative genitive singular)
merkintäkielenne (accusative genitive plural)
merkintäkielenne (genitive singular)
merkintäkieltenne (genitive plural)
merkintäkielienne (genitive plural)
merkintäkieltänne (partitive singular)
merkintäkieliänne (partitive plural)
merkintäkielessänne (inessive singular)
merkintäkielissänne (inessive plural)
merkintäkielestänne (elative singular)
merkintäkielistänne (elative plural)
merkintäkieleenne (illative singular)
merkintäkieliinne (illative plural)
merkintäkielellänne (adessive singular)
merkintäkielillänne (adessive plural)
merkintäkieleltänne (ablative singular)
merkintäkieliltänne (ablative plural)
merkintäkielellenne (allative singular)
merkintäkielillenne (allative plural)
merkintäkielenänne (essive singular)
merkintäkielinänne (essive plural)
merkintäkieleksenne (singular translative)
merkintäkieliksenne (plural translative)
merkintäkielettänne (abessive singular)
merkintäkielittänne (abessive plural)
merkintäkielinenne (comitative plural)
merkintäkielensä (nominative singular)
merkintäkielensä (nominative plural)
merkintäkielensä (accusative nominative singular)
merkintäkielensä (accusative nominative plural)
merkintäkielensä (accusative genitive singular)
merkintäkielensä (accusative genitive plural)
merkintäkielensä (genitive singular)
merkintäkieltensä (genitive plural)
merkintäkieliensä (genitive plural)
merkintäkieltään (partitive singular)
merkintäkieltänsä (partitive singular)
merkintäkieliään (partitive plural)
merkintäkieliänsä (partitive plural)
merkintäkielessään (inessive singular)
merkintäkielessänsä (inessive singular)
merkintäkielissään (inessive plural)
merkintäkielissänsä (inessive plural)
merkintäkielestään (elative singular)
merkintäkielestänsä (elative singular)
merkintäkielistään (elative plural)
merkintäkielistänsä (elative plural)
merkintäkieleensä (illative singular)
merkintäkieliinsä (illative plural)
merkintäkielellään (adessive singular)
merkintäkielellänsä (adessive singular)
merkintäkielillään (adessive plural)
merkintäkielillänsä (adessive plural)
merkintäkieleltään (ablative singular)
merkintäkieleltänsä (ablative singular)
merkintäkieliltään (ablative plural)
merkintäkieliltänsä (ablative plural)
merkintäkielelleen (allative singular)
merkintäkielellensä (allative singular)
merkintäkielilleen (allative plural)
merkintäkielillensä (allative plural)
merkintäkielenään (essive singular)
merkintäkielenänsä (essive singular)
merkintäkielinään (essive plural)
merkintäkielinänsä (essive plural)
merkintäkielekseen (singular translative)
merkintäkieleksensä (singular translative)
merkintäkielikseen (plural translative)
merkintäkieliksensä (plural translative)
merkintäkielettään (abessive singular)
merkintäkielettänsä (abessive singular)
merkintäkielittään (abessive plural)
merkintäkielittänsä (abessive plural)
merkintäkielineen (comitative plural)
merkintäkielinensä (comitative plural)


unpickle

en-verb

unpickle (third-person singular simple present unpickles, present participle unpickling, simple past and past participle unpickled)

unpickles (present singular third-person)
unpickling (participle present)
unpickled (participle past)
unpickled (past)

To reconstruct the message, the receiver must strip the length header, read the entire message, unpickle the contents, and call logging.makeLogRecord().

2009, David M. Beazley, Python essential reference, page 362:

(transitive, programming, in the Python programming language) To deserialize.


dispatch table

(programming) A table of pointers to functions or methods, commonly used to implement dynamic binding.


unbless

unbless (third-person singular simple present unblesses, present participle unblessing, simple past and past participle unblessed)

unblesses (present singular third-person)
unblessing (participle present)
unblessed (participle past)
unblessed (past)

(transitive, computing, programming, Perl) To convert (a previously blessed object) back to a simple reference.


embarrassingly parallel

en-adj

embarrassingly parallel (comparative more embarrassingly parallel, superlative most embarrassingly parallel)

more embarrassingly parallel (comparative)
most embarrassingly parallel (superlative)

/ɪmˌbæɹəsɪŋli ˈpæɹəlɛl/

/əmˈbɛɹəsɪŋli ˈpɛɹəˌlɛl/

From embarrassingly (in the sense of being embarrassingly or extremely easy) + parallel.

We call such applications "embarrassingly parallel" to emphasize the fact that, while there is a high degree of parallelism and it is possible to make efficient use of many processors, the granularity is large enough that no cooperation between the processors is required within the matrix computations.

1986, Cleve Moler, “Matrix Computation on Distributed Memory Multiprocessors”, in Michael T[homas] Heath, editor, Hypercube Multiprocessors 1986, Philadelphia, Pa.: Society for Industrial and Applied Mathematics, →ISBN, part IV (Numerical Computations), page 182:

In the product algorithm, in fact, only one arithmetic operation, a multiplication, is required, so with a sufficient number of processors it executes in constant time regardless of the degree of the result. […] This is the "embarrassingly parallel" aspect of the algorithms: doing this part in parallel is so trivial it's hardly worth mentioning.

1992, Dennis Weeks, “Embarrassingly Parallel Algorithms for Algebraic Number Arithmetic”, in Richard E. Zippel, editor, Computer Algebra and Parallelism: Second International Workshop, Ithaca, USA, May 9–11, 1990: Proceedings (Lecture Notes in Computer Science; 584), Berlin; Heidelberg, Baden-Württemberg: Springer-Verlag, →ISBN, page 63:

Both of the example applications we've looked at here would be considered embarrassingly parallel. […] By contrast, most parallel sorting algorithms require a great deal of interaction. For instance, consider merge sort, a common method of sorting numbers. It breaks the vector to be sorted into two (or more) independent parts, say the left half and right half, which are then sorted in parallel by two processes. So far, this is embarrassingly parallel, at least after the vector is divided in half. But then the two sorted halves must be merged to produce the sorted version of the original vector, and that process is not embarrassingly parallel.

2011, Norman Matloff, “Parallel R”, in The Art of R Programming: A Tour of Statistical Software Design, San Francisco, Calif.: No Starch Press, →ISBN, page 347:

We develop a parallel variational inference (VI) procedure for use in data-distributed settings, where each machine only has access to a subset of data and runs VI independently, without communicating with other machines. […] [W]e make use of the recently proposed nonparametric VI to facilitate an embarrassingly parallel VI procedure that can be applied to a wider scope of models, including to nonconjugate models. We derive our embarrassingly parallel VI algorithm, analyze our method theoretically, and demonstrate our method empirically on a few nonconjugate models.

2015 October 14, Willie Neiswanger, Chong Wang, Eric Xing, “Embarrassingly Parallel Variational Inference in Nonconjugate Models”, in arXiv, Ithaca, N.Y.: Cornell University, →DOI, →ISSN, →OCLC, abstract:

(programming, parallel computing, of a particular problem) Very easy to separate into a number of parallel tasks.

過易並行 /过易并行

in parallel computing, of a particular problem: very easy to separate into a number of parallel tasks


C`num`

Inspired by the sharp symbol in musical notation. Also chosen because this symbol resembles four connected + symbols; see etymology for C++.

VBers may find the syntax of C# a bit unpalatable.

2008, Andrew Troelsen, Visual Basic .NET and the .NET Platform: An Advanced Guide, page XVIII:

(programming) An object-oriented programming language, resembling Java in some respects, developed by Microsoft Corporation as part of their .NET Framework initiative.


pre-hook

(computing, programming) A section of code that runs immediately before a hook call.


polyfill

Named with reference to the spackling paste Polyfilla.

A common way to group elements for collective use by JavaScript is to assign them the same (CSS) class and then to use getElementsByClassName(). Possibly with a polyfill for the "certain old browser".

2016 April 17, Stefan Weiss, “A few problems with looping thru a set of elements with the same "name" specifier.”, in comp.lang.javascript (Usenet), message-ID <nf03hk$bll$1@news.albasani.net>:

(web development) A plugin that provides the functionality of newer browsers to older versions.

ポリフィル

plugin that provides functionality of newer browsers


polyfill

en-verb

polyfill (third-person singular simple present polyfills, present participle polyfilling, simple past and past participle polyfilled)

polyfills (present singular third-person)
polyfilling (participle present)
polyfilled (participle past)
polyfilled (past)

See the FAQ. Or polyfill String.prototype.trim() if necessary and just call .trim().

2017 January 17, Thomas 'PointedEars' Lahn, “form sending undefined”, in comp.lang.javascript (Usenet), message-ID <1645793.CQOukoFCf9@PointedEars.de>:

(web development, transitive, intransitive) To create or apply a polyfill.


forkomenti

eo-head

forkomenti (present forkomentas, past forkomentis, future forkomentos, conditional forkomentus, volitive forkomentu)

forkomentas (present)
forkomentis (past)
forkomentos (future)
forkomentus (conditional)
forkomentu (volitive)
forkomentas (present)
forkomentis (past)
forkomentos (future)
forkomentanta (active participle present singular)
forkomentantaj (active participle plural present)
forkomentinta (active participle past singular)
forkomentintaj (active participle past plural)
forkomentonta (active future participle singular)
forkomentontaj (active future participle plural)
forkomentantan (accusative active participle present singular)
forkomentantajn (accusative active participle plural present)
forkomentintan (accusative active participle past singular)
forkomentintajn (accusative active participle past plural)
forkomentontan (accusative active future participle singular)
forkomentontajn (accusative active future participle plural)
forkomentata (participle passive present singular)
forkomentataj (participle passive plural present)
forkomentita (participle passive past singular)
forkomentitaj (participle passive past plural)
forkomentota (future participle passive singular)
forkomentotaj (future participle passive plural)
forkomentatan (accusative participle passive present singular)
forkomentatajn (accusative participle passive plural present)
forkomentitan (accusative participle passive past singular)
forkomentitajn (accusative participle passive past plural)
forkomentotan (accusative future participle passive singular)
forkomentotajn (accusative future participle passive plural)
forkomentanto (active noun-from-verb participle present singular)
forkomentantoj (active noun-from-verb participle plural present)
forkomentinto (active noun-from-verb participle past singular)
forkomentintoj (active noun-from-verb participle past plural)
forkomentonto (active future noun-from-verb participle singular)
forkomentontoj (active future noun-from-verb participle plural)
forkomentanton (accusative active noun-from-verb participle present singular)
forkomentantojn (accusative active noun-from-verb participle plural present)
forkomentinton (accusative active noun-from-verb participle past singular)
forkomentintojn (accusative active noun-from-verb participle past plural)
forkomentonton (accusative active future noun-from-verb participle singular)
forkomentontojn (accusative active future noun-from-verb participle plural)
forkomentato (noun-from-verb participle passive present singular)
forkomentatoj (noun-from-verb participle passive plural present)
forkomentito (noun-from-verb participle passive past singular)
forkomentitoj (noun-from-verb participle passive past plural)
forkomentoto (future noun-from-verb participle passive singular)
forkomentotoj (future noun-from-verb participle passive plural)
forkomentaton (accusative noun-from-verb participle passive present singular)
forkomentatojn (accusative noun-from-verb participle passive plural present)
forkomentiton (accusative noun-from-verb participle passive past singular)
forkomentitojn (accusative noun-from-verb participle passive past plural)
forkomentoton (accusative future noun-from-verb participle passive singular)
forkomentotojn (accusative future noun-from-verb participle passive plural)
forkomentante (active adverbial participle present)
forkomentinte (active adverbial participle past)
forkomentonte (active adverbial future participle)
forkomentate (adverbial participle passive present)
forkomentite (adverbial participle passive past)
forkomentote (adverbial future participle passive)
forkomenti (infinitive plural present)
forkomentu (imperative past plural)
forkomentus (conditional future plural)


Common Language Specification

Common Language Infrastructure
Common Language Infrastructure

(programming) A subset of the base Common Type System comprising the rules to which any CLS-compliant language targeting the Common Language Infrastructure should conform.


member function

en-noun

member function (plural member functions)

(programming) A function that belongs to a class and can be called on instances of the object defined by that class.


MSIL

Intermediate Language
intermediate language#English

(programming) Abbreviation of Microsoft Intermediate Language.


P/Invoke

Platform Invocation Services
w:Platform Invocation Services

(programming) Abbreviation of Platform Invocation Services.


MVVM

(computing, programming) Initialism of Model–View–ViewModel.


view model

View Models and headless Fragments provide two such mechanisms that ensure data is persisted across configuration changes, while also ensuring that your Activity or Fragment UI can be updated without risk of memory leaks.

2018, Reto Meier, Ian Lake, Professional Android, John Wiley & Sons, →ISBN, page 248:

Once the view model has data requested by the user's event, it notifies and updates the view.

2022, Damodar Lohani, Taking Flutter to the Web […] , Packt Publishing Ltd, →ISBN, page 79:

architectural pattern
architectural pattern

(programming) An abstraction of a view, especially in the context of the MVVM architectural pattern.


hackathon

If these are opinions I'm sure that it happens to have something to do with the immense amounts of caffeine and sugar that I've ingested over the course of his 50hr hackathon.

1985 January 20, Andy Beals, “Re: net.men.only?”, in net.flame (Usenet), retrieved 2016-12-16, message-ID <3466@mit-eddie.UUCP>:

Just after the Hack-A-Thon. A little tired, but it's still early, just after 3 a.m. I log onto^([sic]) the Vax and find that two of the people from the Hack-A-Thon are already on. I VMSphone RJLEWIS, a hacker and the president of our computer club, to ask him why he left the 'thon early. He answers after quite a few rings - no surprise, he was probably doing some hacking. He answers, "This isn't Crash." Hmm...probably one of his roommates. Another person joins the conversation - RLCOLLINS, one of his roommates - saying "This is Crash." Ok, I'm confused. "Why?," I ask. RJLEWIS responds that this is a person named Debbie and it's her first time on the computer.

1990 November 30, P'relan, “A Callahan's Romance”, in alt.callahans (Usenet), retrieved 2016-12-16, message-ID <3009.27556011@miavx1.acs.muohio.edu>:

I bet you most programmers started out "hacking." You think you're alone in that, but I'm sure you can find hundreds of people in this newsgroup with "48-hour hack-a-thon" or similar kinds of stories. They may have been working with punched cards or with all-text displays, but hacking is hacking. That's why some of the dreaded professional programmers will see your fixation with obscure tricks as nothing more than a phase they've been through themselves.

1992 February 29, David M. Baggett, “Re: 'Demo crews'”, in comp.sys.atari.st (Usenet), retrieved 2016-12-16, message-ID <1992Feb29.043440.25994@wam.umd.edu>:

UNITED ARTISTS, THE ONION, AND THE VIRTUAL GAMING CENTER PERSENT: THE 24 HOUR HACKATHON! n promotion of the new moive "HACKERS" (the fast-paced cyberpunk thriller opens in theaters September 15th), we are giving away a some great prizes! Be the first person to "hack" into our special web site on the internet and win a BRAND NEW COMPUTER SYSTEM! Fifty runners-up will receive special HACKERS gift packs.

1995 September 1, James Dicke, “HACKERS: Win a new computer!”, in milw.general (Usenet), retrieved 2016-12-16, message-ID <4282s8$15l@earth.alpha.net>:

Startup Bus is arguably the looniest of the many hackathons that take place every weekend across the country. A hackathon is a marathon computer-programming competition that, among computer programmers, is slightly less popular than video games, Ultimate Frisbee, or Game of Thrones. It lasts 24 hours to five days, and usually there is a lot of Red Bull and very little sleep.

2015 July 8, Meredith Broussard, “The Dirty Secret About Hackathons”, in The Atlantic:

(informal) An event where programmers and others meet for collaborative software development, usually over several days.


application programming interface

application programming interface (plural application programming interfaces)

application programming interfaces (plural)

(computing, programming) A set of routines, protocols, and tools for building software applications, which makes it possible for software components to interact with one another.

interface de programmation d'application

интерфе́йс программи́рования приложе́ний

interfaz de programación de aplicaciones


Programmierschnittstelle

de-noun

Programmierschnittstelle f (genitive Programmierschnittstelle, plural Programmierschnittstellen)

Programmierschnittstelle (genitive)
Programmierschnittstellen (plural)
Programmierschnittstelle (nominative singular)
Programmierschnittstellen (definite nominative plural)
Programmierschnittstelle (genitive singular)
Programmierschnittstellen (definite genitive plural)
Programmierschnittstelle (dative singular)
Programmierschnittstellen (dative definite plural)
Programmierschnittstelle (accusative singular)
Programmierschnittstellen (accusative definite plural)

[pʁoɡʁaˈmiːɐ̯ˌʃnɪtʃtɛlə]

application programming interface
application programming interface


uygulama programlama arayüzü

head

uygulama programlama arayüzü (definite accusative uygulama programlama arayüzünü, plural uygulama programlama arayüzleri)

uygulama programlama arayüzünü (accusative definite)
uygulama programlama arayüzleri (plural)

(software) application programming interface


واجهة برمجة تطبيقات

ar-noun

وَاجِهَة بَرْمَجَة تَطْبِيقَات

وَاجِهَات بَرْمَجَة تَطْبِيقَات

وَاجِهَة بَرْمَجَة تَطْبِيقَات • (wājihat barmajat taṭbīqāt) f (plural وَاجِهَات بَرْمَجَة تَطْبِيقَات (wājihāt barmajat taṭbīqāt))

وَاجِهَة بَرْمَجَة تَطْبِيقَات (canonical)
wājihat barmajat taṭbīqāt (romanization)
وَاجِهَات بَرْمَجَة تَطْبِيقَات (plural)
وَاجِهَة بَرْمَجَة تَطْبِيقَات (ar-infl-a indefinite informal singular triptote)
وَاجِهَة بَرْمَجَة التَّطْبِيقَات (ar-infl-a definite informal singular triptote)
وَاجِهَة بَرْمَجَة تَطْبِيقَات (ar-infl-a construct informal singular triptote)
وَاجِهَةُ بَرْمَجَةِ تَطْبِيقَاتٍ (ar-infl-a indefinite nominative singular triptote)
وَاجِهَةُ بَرْمَجَةِ التَّطْبِيقَاتِ (ar-infl-a definite nominative singular triptote)
وَاجِهَةُ بَرْمَجَةِ تَطْبِيقَاتِ (ar-infl-a construct nominative singular triptote)
وَاجِهَةَ بَرْمَجَةِ تَطْبِيقَاتٍ (accusative ar-infl-a indefinite singular triptote)
وَاجِهَةَ بَرْمَجَةِ التَّطْبِيقَاتِ (accusative ar-infl-a definite singular triptote)
وَاجِهَةَ بَرْمَجَةِ تَطْبِيقَاتِ (accusative ar-infl-a construct singular triptote)
وَاجِهَةِ بَرْمَجَةِ تَطْبِيقَاتٍ (ar-infl-a genitive indefinite singular triptote)
وَاجِهَةِ بَرْمَجَةِ التَّطْبِيقَاتِ (ar-infl-a definite genitive singular triptote)
وَاجِهَةِ بَرْمَجَةِ تَطْبِيقَاتِ (ar-infl-a construct genitive singular triptote)
وَاجِهَتَيْ بَرْمَجَة تَطْبِيقَات (ar-infl-a dual indefinite informal singular triptote)
وَاجِهَتَيْ بَرْمَجَة التَّطْبِيقَات (ar-infl-a definite dual informal singular triptote)
وَاجِهَتَيْ بَرْمَجَة تَطْبِيقَات (ar-infl-a construct dual informal singular triptote)
وَاجِهَتَا بَرْمَجَةِ تَطْبِيقَاتٍ (ar-infl-a dual indefinite nominative singular triptote)
وَاجِهَتَا بَرْمَجَةِ التَّطْبِيقَاتِ (ar-infl-a definite dual nominative singular triptote)
وَاجِهَتَا بَرْمَجَةِ تَطْبِيقَاتِ (ar-infl-a construct dual nominative singular triptote)
وَاجِهَتَيْ بَرْمَجَةِ تَطْبِيقَاتٍ (accusative ar-infl-a dual indefinite singular triptote)
وَاجِهَتَيْ بَرْمَجَةِ التَّطْبِيقَاتِ (accusative ar-infl-a definite dual singular triptote)
وَاجِهَتَيْ بَرْمَجَةِ تَطْبِيقَاتِ (accusative ar-infl-a construct dual singular triptote)
وَاجِهَتَيْ بَرْمَجَةِ تَطْبِيقَاتٍ (ar-infl-a dual genitive indefinite singular triptote)
وَاجِهَتَيْ بَرْمَجَةِ التَّطْبِيقَاتِ (ar-infl-a definite dual genitive singular triptote)
وَاجِهَتَيْ بَرْمَجَةِ تَطْبِيقَاتِ (ar-infl-a construct dual genitive singular triptote)
وَاجِهَات بَرْمَجَة تَطْبِيقَات (feminine indefinite informal plural sound-form)
وَاجِهَات بَرْمَجَة التَّطْبِيقَات (definite feminine informal plural sound-form)
وَاجِهَات بَرْمَجَة تَطْبِيقَات (construct feminine informal plural sound-form)
وَاجِهَاتُ بَرْمَجَةِ تَطْبِيقَاتٍ (feminine indefinite nominative plural sound-form)
وَاجِهَاتُ بَرْمَجَةِ التَّطْبِيقَاتِ (definite feminine nominative plural sound-form)
وَاجِهَاتُ بَرْمَجَةِ تَطْبِيقَاتِ (construct feminine nominative plural sound-form)
وَاجِهَاتِ بَرْمَجَةِ تَطْبِيقَاتٍ (accusative feminine indefinite plural sound-form)
وَاجِهَاتِ بَرْمَجَةِ التَّطْبِيقَاتِ (accusative definite feminine plural sound-form)
وَاجِهَاتِ بَرْمَجَةِ تَطْبِيقَاتِ (accusative construct feminine plural sound-form)
وَاجِهَاتِ بَرْمَجَةِ تَطْبِيقَاتٍ (feminine genitive indefinite plural sound-form)
وَاجِهَاتِ بَرْمَجَةِ التَّطْبِيقَاتِ (definite feminine genitive plural sound-form)
وَاجِهَاتِ بَرْمَجَةِ تَطْبِيقَاتِ (construct feminine genitive plural sound-form)

Literally "application programming interface" (even more literally, "interface of the programming of applications"). وَاجِهَة (wājiha, “front, exposure”) has the meaning "interface" in conjunction with بَرْمَجَة (barmaja, “programming”).


watchpoint

From watch + point, on the model of breakpoint.

AdaRAID supports multiple CPUs running concurrently, Ada data types, features include break points, watchpoints, timing, tracing, stepping, walkbacks, and histories of last n executions.

(programming) A debugging mechanism whereby execution is suspended every time a specified memory location is modified; or, any of various similar such mechanisms.