Skip to content

Code abbreviations

abbr: abbreviation

abs: absolute

acc: accumulator

acd: abstract concept declaration

act: actual/action/active

ad: aspect descriptor

addr: address

agg: aggregation

algo: algorithm

alloc: allocation

alt: alternative

am: abstract module

anc: ancestor

anno: annotation

app: application

arch: architecture

arg: argument

arr: array

art: artifact

ass: assessment

ast: abstract syntax tree

async: asynchronous

attr: attribute

auth: authentication

aux: auxiliary

avg: average

bais: byte array input stream

baos: byte array output stream

bb: byte buffer

bc: build configuration

bd: big decimal

bg: background/button group

bhvr: behavior

bim: buffered image

bis: buffered input stream

bl: base language/baseline

bos: byte array output stream

bool: boolean

bp: breakpoint/binary persistence

bin: binary

br: buffered reader/break

bt: base type

btn: button

buf: buffer

buff: buffer

ca: concept argument/child adopter

calc: calculator/calculation

cat: category

cb: callback

cc: class concept

cd: concept declaration

ced: concept editor declaration

cert: certificate

cfg: configuration

ch: character/channel

char: character

chk: check

csum: checksum

ci: config item

circ: circle

cl: classloader

clm: classloader manager

clr: clear

cls: class

cmd: command

cme: cross-model environment

cmp: compare/comparison

com: commercial/common/communication

comm: common

cos: cosine

cot: cotangent

cn: context node

cncpt: concept

cnt: count/counter

col: column

coll: collection

comp: component

concat: concatenation

conf: configuration

config: configuration

cond: condition

conn: connection

cons: constructor

const: constant

conv: conversation

coord: coordinate

cp: checkpoint (state)/copy/current process

cpb: concept presentation builder

cr: concept reference/registry

cs: change set/collection sequence

ct: classifier/current type

ctrl: control

ctx: context

cpy: copy

cur: current

curr: current

db: database

dbg: debug

dbgr: debugger

dcl: declaration

dec: decimal/decrease

decl: declaration

def: definition/default

del: deletion

dep: dependency

desc: description

descr: description

dest: destination

dev: developer/development/device

df: decimal format

di: debug info

dir: direction/directory

diff: difference

dim: dimension

dis: disable

disp: display

dir: directory

div: division

dk: delta key/devkit

doc: document/documentation

drv: driver

dr: dynamic reference

ds: data source

dsm: default semantic model

dst: destination

dt: delta time

dx: difference x

dy: difference y

dyn: dynamic

ec: editor component

ec: editor context

ecf: editor cell factory

ed: enumeration declaration/extension descriptor

eg: engaged generator/example given

el: element

en: enable

env: environment

eof: end of file

ep: else part/element provider/extension point

eq: equal/equation

err: error

et: element type

evt: event

ex: exception/executor

exe: executable/execution

expr: expression

ext: extension

fac: factory

fc: file chooser/first child

fct: facet

fd: file description

fdc: file delta collector

fig: figure

fmt: format

fn: function

fp: file processor/function pointer

fqn: full qualified name

fr: file reader

frac: fraction

freq: frequence

fs: file system

fsm: file status manager

ft: float type/file tracker

fun: function

fw: file writer

fwiw: for whomever is wondering

fyi: for your information

gd: graphics device/generator descriptor

ge: graphics environment/greater or equal

gen: generation

gm: generator module/generator mappings

gms: generator module scanner/model generation status manager

gp: generation plan/partitioner

gr: generator

gt: greater than

gtf: generation target facet

gvd: global variable declaration

hdr: header

hex: hexadecimal

hm: hashmap

hor: horizontal

horz: horizontal

href: hyper-reference

hs: HashSet

hsb: hue/saturation/brightness

id: identification/identifier

idx: index

img: image

imp: import

impl: implementation

inc: increase/inclusion

info: information

init: initialization

ins: insertion

inst: instance

int: integer

intf: interface

intfc: interface concept

ir: icon resource

isr: input stream reader

iter: iterator

qec: query execution context

jftr: just for the record

jc: Java compiler

js: JavaScript

jmf: Java module facet

km: keymap

kv: key value

kwd: keyword

la: line annotation

lang: language

lat: latitude

lca: lowest common ancestor

lcv: lower-case value

ld: link declaration/descriptor

le: less or equal

len: length

lf: line feed

lhs: left-hand side

lib: library

ll: linked list

lm: labeled mappings

lnk: link

loc: location

lon: longitude

lr: language registry/runtime

ls: list of strings

ls: list sequence

lt: left type

lvd: local variable declaration

lvl: level

ma: model access

mac: macOS

mat: matrix

mah: model access helper

max: maximum

mc: mapping configuration

md: model

mdm: model dependencies manager

mdr: model dependency resolver

mem: member/memory

meta: metadata

meth: method

mf: manifest

mf: model factory

mg: models generator

mgr: manager

mgsm: module generation status manager

mi: model imports/internal model

mid: middle

min: minimum

mis: model input stream

misc: miscellaneous

ml: module loader/model

mm: modules miner

mn: model name

mng: manager

mo: module options

mod: modulo

mos: model output stream

mp: model persistence

mplr: multiplier

mr: model/module reference/model root/model/module repository

mrd: model root descriptor

mrf: module repository facade

msg: message

mul: multiplication

mut: mutable

mv: module dependency versions

nav: navigation

nb: node builder

nbn: node builder node

nc: named concept

ne: not equal/expression

net: network

nl: new line/number literal

nm: nodes matcher

np: null pointer/node pointer

nr: number/node reference

ns: name source/space

nuli: number literal

num: number (of)

nut: node under test

nwf: node weave support

obj: object

oct: octal

ord: order

ois: object input stream

oos: object output stream

op: operation/operator

opt: option/optional

org: organization

orig: origin

os: operation system

otoh: on the other hand

out: output

pa: property attribute

param: parameter

pb: popup builder

pd: parameter declaration/property descriptor

perf: performance

pf: persistence facade

ph: phase

pic: picture

pkg: package

pm: project manager

pma: project model access

pol: polygon

pred: predication/predicate

pos: position

pwr: power

pp: project pane

pq: priority queue

pref: preference

priv: private

prev: previous

proc: process

prod: production

prof: profiler

prog: program

proj: project

prop: property

psc: package scope control

pt: primitive type/pointer type/performance tracer

ptg: parallel template generator

ptr: pointer

pub: public

pw: print writer

px: pixel/position x

py: position y

qry: query

ra: read action

rand: random

rc: rule consequence

rd: reference descriptor

rec: rectangle/record

ref: reference

rel: relative

repo: repository

req: requirement

res: result

ret: return

rgb: red/blue/green

rhs: right-hand side

rl: reference link

rm: remove/root model

rnd: random

rng: range

rect: rectangle

recv: receive

regex: regular expression

rem: remote

req: request

res: response/result

ret: return

rev: revision

rm: remove

rt: right type/runtime/result type/result type

rv: result value

sa: style attribute

sb: string builder/buffer

sc: script

sca: smart completion action

scb: script builder

scs: subconcepts

sd: solution descriptor

sdk: software development kit

sdmd: semantic model model descriptor

sec: section

sel: selector/selection

sem: semaphore

sep: separator

seq: sequence

sess: session

sfr: static field reference

si: substitute info

sin: sine

sl: selection/statement list

sln: solution

sm: semantic model/state machine

smc: static method call

sn: semantic node

snt: snode type

sol: solver

sp: settings provider

spec: specification

sqrt: square root

sr: search results/source root

src: source

st: solver task/string tokenizer

stat: statistic

std: standard

stmt: statement

str: string

sub: subtraction

sum: addition

sync: synchronization

sw: string writer

ta: text area

tc: TeamCity/template context/template call

td: table data/type definition/target declaration

tee: template execution environment

teei: template execution environment implementation

temp: temporary

tf: template fragment

tg: template generator/thread group

tgl: toggle

tgs: text generation support

tgt: target

th: throwable

ti: test item

tm: table model

tm: template module

tmp: temporary/temperature

tmr: timer

tn: target node/tree node

tpe: type

tqc: template query context

tr: table row/trigger

trd: thread

trf: transferable

tsc: type size configuration

tt: transition trace

tv: text value

tvr: type variable reference

tx: transaction

txt: text

ud: used dependency

ui: user interface

ul: used language

util: utilities

usr: user

uo: user object

val: value

var: variable

vc: value container

vd: variable declaration

vep: visible element provider

ver: version/vertical

vert: vertical

vf: virtual file

vfs: virtual file system

vp: view port/virtual package

wa: write action

win: window/Windows

wiz: wizard

wrk: worker

wrt: with reference to

ws: white space

zf: zip file