Codish Lexicon

accept — to accept a connection from a client.   perl: [socket]: accept an incoming [socket] [connect]†   mentioned: server ✍

connection — mentioned: accept ✍

client — a process on a host that makes requests in a protocol.   opposite: server   related: local   mentioned: accept, response ✍

server — a program that observes a port for requests and accepts connections for communication with a protocol.   opposite: client   related: remote   mentioned: response ✍

local — the client host from a program's perspective.   opposite: remote   distinct: scope   perl: create a temporary value for a global variable (dynamic scoping)†   related: client   mentioned: def, frame, load, raise, save ✍

process — an application (apply) of a program, mediated by the os.   distinct: thread, program   mentioned: client, continuation, pump, queue, semaphore, wait ✍

host — mentioned: client, local, remote ✍

request — a message sent froma client to a server per a protocol. ✍

protocol — an algorithm that governs mutual communication through requests, responses, and state.   mentioned: client, server ✍

response — a message sent by a server to a client per a protocol. ✍

remote — a server host.   opposite: remote   opposite: local   related: server   mentioned: load, save ✍

observe — to request that a signal send events to an observer.   aka: watch, listen, add event listener   distinct: subscribe   mentioned: at, server ✍

port — mentioned: server ✍

connect — perl: [socket]: connect to a [remote] [socket]†   mentioned: server ✍

scope — an object that associates symbols or names with values for a block of code and can include a ref to another scope to defer to if a symbol does not exist, conceptually forming a stack with the current scope at the head.   related: function   aka: lexical scope   distinct: local   mentioned: closure, context, def, enclosure, global, keyword, stateful, var ✍

program — instructions that dictate the execution of a process when they are run.   distinct: process   distinct: thread ✍

def — to define; to put a local variable in the current scope of a context.   aka: value   distinct: var ✍

frame — the arguments, local variables, and a ref to the return frame (often implied by location in an array-like structure) of a function application.   related: function   mentioned: apply, bind, closure, continuation, raise, stack ✍

load — to transfer remote data to a more local memory.   opposite: save   distinct: get   aka: retrieve ✍

raise — to interrupt the execution of a program, unwinding the stack of each block until a try block with a handler block matching the pattern or class of the raised exception is found.   in c++, raising is called throw, and also causes the deallocation of local variables in each unwound stack frame.   aka: throw   java: throw   c++: throw   python: raise   mentioned: assert, error, handle ✍

save — to transfer local date to a more remote memory.   opposite: load   distinct: set ✍

thread — an application (apply) or continuation of a function, mediated by a process that shares memory with other threads in the same process.   distinct: process, program   mentioned: atomic, queue, wait ✍

apply — to eval or exec a function. this involves creating a frame, passing parameters to arguments, and evaluating or executing each statement in the function's block.   aka: invoke   python: apply(object[, args[, kwargs]]) -> value Call a callable object with positional arguments taken from the tuple args, and keyword arguments taken from the optional dictionary kwargs. Note that classes are callable, as are instances with a __call__() method.†   aka: application ✍

os — operating system.   mentioned: file, pipe, process, semaphore ✍

continuation — the state of a process or thread that includes the cursor of execution and all of the frames for functions that the process must return to before completion.   aka: context   mentioned: cps ✍

pump — a process that assertively reads from one stream and echoes the values in order to another stream. ✍

queue — a linear collection that only provides shift and push for storage and retrieval, such that the first value pushed is always the first value shifted (fifo).   queues operations are often atomic, so they can be used to pass messages safely between threads or processes.   aka: dequeue, enqueue   distinct: signal   mentioned: linear collection, list, ordered, que ✍

semaphore — an object, mediated by an os, that programs can use to mediate the use of shared resources by forcing a process to wait. ✍

wait — to stop execution pending a condition like the availability of data on a input stream or a process or thread's termination.   distinct: block, join   perl: [process]: wait for any child process to die†   mentioned: semaphore ✍

state — data that is relevant to the flow of an algorithm at a particular time, sometimes representable as a cursor pointing at a vertex in a graph or machine.   the cursor in a machine.   an observable state sends a signal when a cursor arrives at the state.   aka: stateful   mentioned: continuation, iteration, protocol ✍

subscribe — related: subscriber   opposite: publish   distinct: observe ✍

watch — to observe a visual signal.   see: observe ✍

listen — to observe an aural signal.   perl: [socket]: register your [socket] as a [server]; see: observe†   see: observe ✍

add event listener — see: observe ✍

signal — a function that sends a signal, notifying observers when an event has occured.   related: promise   distinct: queue   classes: done   distinct: publish   mentioned: finish, listen, observable, observe, signaler, state, watch ✍

send — to create an event for a signal and send it to obervers.   aka: dispatch, fire, notify   distinct: write   perl: [socket]: [send] a [message] over a [socket]†   aka: recv   distinct: publish   opposite: recieve   mentioned: observe, observer, state ✍

event — a message that a signal sends to its observers. some events propagate, can stop, or have a default behavior.   aka: note, message   related: message   mentioned: observe ✍

observer — a function or object that has requested that a signal send a particular event when it occurs.   aka: listener, handler   distinct: handler   mentioned: at, message, observe, when ✍

at — observe a moment or schedule with an observer.   at(moment, observer)   is: temporal   distinct: get ✍

function — related: scope, frame, closure   includes: apply   classes: binary function, boolean function ✍

lexical scope — all of the variables named in a context.   see: scope, lexical   mentioned: free var ✍

object — an instance of a class.   see: set attr, get attr, has attr, del attr   python: The most base type.†   distinct: dict   aka: instance, record, struct, structure ✍

symbol — a unique key for the value of an attr on an object.   symbols can be used to accelerate attribute lookup, and to provide a way to avoid name collisions for interface implementations. symbols can be integers with a non-unique string representation.   aka: word   mentioned: aliaser, del attr, get attr, override, polymorphism, scope, semantics, set attr, syntax ✍

name — a string used to look up a variable in a context   python: file: file name.†   aka: nomen, term, word ✍

value — data of any class.   see: def, variable   aka: datum   related: dict ✍

block — a list of program statements.   distinct: wait, join   mentioned: apply, raise, scope ✍

ref — reference.   a representation of a integer that identifies the location of an object in memory.   a reference may be an opaque object, meaning that having a reference does not necessarily imply knowledge of the underlying integer value.   references may be strong or weak for purpose of garbage collection, and may imply the location of supplementary data like a reference counter or class annotations.   distinct: pointer   perl: [class]: find out the type of thing being referenced†   distinct: cursor, identity   related: deref   aka: reference ✍

stack — a linear collection that only provides or guarantees fast push and pop.   seuss: specifically a staque of frames.   mentioned: closure, context, heap array, lifo, linear collection, ordered, raise, scope ✍

head — the first value in an ordered linear collection.   opposite: tail   mentioned: chain, doubly, scope ✍

closure — a function and a ref to the frame it was defined in.   an object that represents a function (for behavior) and the context in which it was created at run-time (for stateful data captured in the scope).   the availability of closures in a language is predicated on run time gc of scopes, with a scope tree instead of a scope stack.   related: enclosure, function ✍