Codish Lexicon

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

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

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 ✍

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

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

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

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. ✍

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 ✍

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

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

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 ✍

connection — mentioned: accept ✍

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 ✍

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 ✍

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 ✍

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 ✍

get — returns the value corresponding to a key in a collection. throws a key error if no value exists for the key, or returns a default value if one is provided as the optional second parameter.   pertains: collection   python: dict: D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None..†   distinct: at, get attr, load   aka: lookup   mentioned: array, attr, cut, getset ✍

retrieve — see: load ✍

data — a collection of meaningful values in memory.   singular: datum   mentioned: atom, atomic, closure, compound, load, message, record, struct, structure ✍

memory — any medium that persists data storage.   classes: register, cache, ram, disk, db   aka: storage ✍

set — to assign a value for a key in an item.   in math, a set is a collection of unique values that meet certain criteria. to avoid ambiguity, such collections are called bags in codish, or uniques in seuss.   distinct: unique, bag   pertains: collection   python: set(iterable) -> set object Build an unordered collection of unique elements.†   distinct: put, save, set attr   aka: store ✍

date — php: format a local time/date &dagger.   mentioned: moment, save ✍

publish — related: publisher   opposite: subscribe   distinct: export, signal, send ✍

subscriber — related: subscribe   opposite: publisher ✍

promise — related: signal ✍

done — is: signal   distinct: ready   aka: finished, complete   distinct: complete ✍

when — enqueue an observer onto a signal. ✍