Start page: ARABART home

Glossary

260 words from this site in plain English. Each one comes with the thing you already know in 2026 that does the same job.

Memory and addresses

A20 line
The 21st address wire. With 20 wires an address past 1 MB wraps back to 0; on later PCs the A20 switch lets it reach almost 64 KB more.
In 2026 An odometer that rolls over, with a switch to add one more digit.
Bit field
A group of bits inside a bigger number that holds its own small value. One 32-bit number can carry several of them side by side.
In 2026 IPv4 addresses, network packet headers and Snowflake ids all pack fields this way.
Seen on Patents
Byte
Eight bits. Enough for one letter of text, or a whole number from 0 to 255.
In 2026 One element of a Uint8Array. A UTF-8 letter of English is still one byte.
Seen on Every ByteDOS for developers
Conventional memory
The first 640 KB of a PC. DOS, its drivers and the running program all share it.
In 2026 The memory one browser tab may use, shared with the runtime.
Far pointer
A 4-byte address on the original PC: a segment and an offset. It reaches anywhere in the first megabyte, where a 2-byte near pointer stays inside one 64 KB block.
In 2026 Every pointer is one plain 64-bit number.
Seen on Digi-TestPort Said Computer SystemsDOS for developersText Editor: Demo
Heap
The pool of memory a program asks for while it runs, with new in C++ or malloc in C. The library keeps a small note next to each block it hands out.
In 2026 The same in C, C++ and Rust. JavaScript and Python manage it for you.
Seen on Text Editor: Demo
Hexadecimal
Counting in base 16, with the digits 0 to 9 and A to F. An h after a number marks it as hex: 10h is 16, FFh is 255. Two hex digits make one byte.
In 2026 0x7FFF in JavaScript and C, #FF8800 in CSS.
Seen on Every ByteKemyam: Group NamesPort Said Computer SystemsPort Said IT DepartmentDOS for developersWINKEY
I/O port
A numbered address for talking to hardware, separate from memory. The IN and OUT instructions read and write it; the EGA card listens on ports 3CEh and 3CFh.
In 2026 Drivers use memory-mapped registers; apps call an API such as WebGPU, Metal or Vulkan.
Seen on Digi-Test
KB (kilobyte)
In DOS, 1,024 bytes. So 64 KB is 65,536 bytes, 640 KB is 655,360 bytes, and 1 MB is 1,048,576 bytes.
In 2026 A KiB. A phone photo today is a few thousand of them.
Seen on DOS for developers
memmove
The C library function that copies a block of bytes to another place, even when the two places overlap. Editors use it to open a gap for a new letter.
In 2026 Array.prototype.copyWithin() in JavaScript, copy_within in Rust.
Memory model
A setting of 16-bit DOS compilers that chooses how big the code and the data may grow. "Small" keeps each in one 64 KB block; "large" lets both grow past it by using 4-byte addresses everywhere.
In 2026 Gone: a 64-bit program has one flat address space, so there is nothing to choose.
Seen on The Brave SunDigi-TestDOS for developers
Memory-mapped I/O
Hardware registers that appear at memory addresses, so ordinary reads and writes control the device.
In 2026 How almost every modern device is driven, from graphics cards to a Raspberry Pi’s pins.
Paragraph
A block of 16 bytes. Segment numbers count in paragraphs, so segment 1 starts 16 bytes after segment 0.
In 2026 Like alignment in memory today: addresses that land on neat boundaries.
Seen on DOS for developers
Protected mode
The mode of later processors that keeps programs apart and reaches far more than 1 MB. DOS programs ran in real mode instead.
In 2026 Where every operating system runs today, so one app cannot touch another.
Real mode
How the PC ran DOS: one megabyte of memory, one program at a time, and every program free to read or write any byte, DOS included.
In 2026 Firmware on a small board such as an Arduino: your code owns the whole machine.
Seen on DOS for developers
Register
A small named slot inside the processor, 16 bits on these PCs: AX, BX, CX, DX and a few more. Programs pass values to DOS and the BIOS in them.
In 2026 The arguments of a function call, kept as close to the processor as possible.
Seen on DOS for developersWINKEY
ROM
Read-only memory: a chip with code built in at the factory. The PC’s BIOS and the video BIOS live in ROM near the top of the first megabyte.
In 2026 Firmware, such as UEFI on the flash chip of a PC.
Segment
A starting point in memory. The processor multiplies the segment by 16 and adds an offset to reach any byte, so an address is written segment:offset, like A000:1F4C.
In 2026 buffer.subarray(segment * 16), then an index into that slice.
Seen on Port Said Computer SystemsDOS for developers
Stack
A last-in, first-out area of memory for return addresses and local values. Calls push onto it; returns pop off it.
In 2026 The call stack you see in a JavaScript error.
Seen on DOS for developers
Upper memory
The top 384 KB of the first megabyte. IBM kept it for the screen’s memory and the built-in chips, so a write there reaches the hardware.
In 2026 Memory-mapped hardware, like the registers of a microcontroller.

Interrupts and services

API
The set of functions one program offers to other programs, with names and inputs that stay the same, so others can build on them.
In 2026 The same word today. It often means a web API over HTTP.
BIOS
The built-in code in ROM on every PC. Programs asked it for basic services by number: INT 10h for the screen, INT 16h for the keyboard.
In 2026 UEFI firmware. Apps no longer call it; the operating system’s drivers talk to the hardware.
Seen on Port Said IT DepartmentDOS for developers
bioskey
Borland's C function for reading the keyboard through the BIOS. It returns the key’s scan code and its character together, so arrows and function keys can be told apart.
In 2026 A keydown event, with both event.code and event.key.
Carry flag
A one-bit flag in the CPU. A DOS service sets it to report an error, and the caller checks it with one jump instruction.
In 2026 A function that returns an error code, or throws.
Seen on WINKEY
DOS
Disk Operating System, MS-DOS or PC DOS. It loads one program at a time and gives it files, memory and the screen through INT 21h.
In 2026 An operating system small enough to read in an afternoon: a program loader plus a file system.
Hook
Putting your own address into an entry of the interrupt table, so calls to that service reach your code first. A good hook passes every call it does not handle on to the old address.
In 2026 Middleware that calls next(), or wrapping a function to watch its calls.
Install check
A question a resident program asks before it loads: “Am I already in memory?” If the answer is yes, it does not load a second copy.
In 2026 A single-instance lock, such as a lock file or a named mutex.
INT 10h
The video service of the BIOS: set a screen mode, draw a pixel, and more. ARABART stands in front of it and adds function 36h, Arabic.
In 2026 A graphics driver’s API.
Seen on ARABART: DemoARABARTArabic BasmallahPort Said IT DepartmentDOS for developers
INT 16h
The keyboard service of the BIOS: wait for a key, or check whether one is waiting.
In 2026 Reading keydown events.
Seen on DOS for developers
INT 21h
The door into DOS. A program puts a function number in a register, such as 09h to print text or 4Ch to exit, and runs int 21h.
In 2026 A system call.
INT 27h
The DOS call that ends a program but keeps it in memory. DX says how many bytes to keep.
In 2026 Starting a background service that keeps running after its installer closes.
Seen on DOS for developers
Interrupt
A numbered event. Hardware fires one when a key goes down or the clock ticks; a program fires one to ask DOS or the BIOS for help. The PC looks up the number in a table and runs that code.
In 2026 An event handler, like addEventListener, and a system call, in one mechanism.
Seen on DOS for developers
Interrupt table
The first 1,024 bytes of memory: 256 addresses, one for each interrupt number. Write a new address into an entry and your code answers that interrupt.
In 2026 A map from event names to handler functions.
Seen on DOS for developers
PSP
Program Segment Prefix: 256 bytes that DOS puts in front of every program it loads. They hold the command line and the way back to DOS.
In 2026 The record an operating system keeps for each running process.
Register calling convention
Giving a function its inputs in the CPU’s registers (AX, BX, CX, DX) instead of in memory. Every DOS and BIOS service worked this way.
In 2026 System calls still do it. On 64-bit Linux the first arguments go in RDI, RSI and RDX.
TSR
Terminate and Stay Resident: a program that ends but keeps its code in memory. It usually sits in front of a system service, so every program after it can call it. ARABART is one.
In 2026 A background service, or middleware in front of an API.
Seen on ARABARTDOS for developers

Program files and packing

Assembler
The tool that turns assembly text into the processor’s bytes. The two main DOS assemblers were Microsoft MASM and Borland TASM.
In 2026 NASM, or the assembler inside every C compiler.
Back-reference
In LZ77 compression, an instruction to copy bytes already rebuilt instead of storing them again. Every repeat shrinks to one small instruction.
In 2026 Like a link to an earlier paragraph instead of pasting it twice.
Seen on Every Byte
COM file
The simplest DOS program: raw code with no header. DOS copies it 256 bytes into one 64 KB block of memory and runs it.
In 2026 A plain script: no manifest, it just runs from the top.
Seen on DOS for developers
Ctrl-Z (1Ah)
The DOS mark for the end of a text. The TYPE command stops printing a file when it reaches this byte.
In 2026 PNG files put 1Ah in their first 8 bytes for the same reason.
Seen on Digi-Test
DIET
A program packer for DOS by Teddy Matsumoto. Every one of Yasser’s program files is packed with DIET 1.00 and unpacks itself in memory when it starts.
In 2026 UPX, or a self-extracting archive.
Seen on Every ByteArabic CommercialPort Said IT DepartmentDOS for developers
Entropy
How varied a run of bytes is, from 0 to 8 bits per byte. In his files, text measures about 5, code about 6.7, and packed DIET data about 7.8.
In 2026 Why a .zip of a .zip does not get any smaller.
Entry point
The first instruction a program runs. An EXE header names it; a COM file always starts at offset 100h.
In 2026 The main field of package.json, or main() itself.
Seen on Every Byte
EXE file
A DOS program that starts with a header: the letters MZ and a small manifest. It says where to start, where the stack goes, and which addresses DOS must fix when it loads the program.
In 2026 A bundle with a package.json in front. Windows .exe files still start with MZ.
Seen on Port Said Computer SystemsDOS for developers
Executable packer
A tool that compresses a program and puts a small unpacker in front. The file is smaller on disk; when it runs, it rebuilds itself in memory first.
In 2026 A self-extracting zip, or gzip on a JavaScript bundle. UPX still does exactly this.
Seen on About
File attribute
A few flags DOS keeps for each file, such as read-only and hidden. A read-only file has to be unlocked before a program can change it.
In 2026 File permissions on macOS and Linux.
Fix-up (relocation)
A spot in a program that holds a real memory address. The program cannot know where DOS will load it, so DOS adds the load address to every spot on the list when it starts.
In 2026 Resolving a relative URL against the page it loaded from.
Seen on Every BytePort Said Computer Systems
Linker
The tool that joins compiled pieces and libraries into one program file. For an EXE it also writes the list of fix-ups. Borland’s linker is TLINK.
In 2026 A bundler such as esbuild or webpack, which joins modules into one file.
Seen on DOS for developers
Load address
Where in memory DOS puts a program. It depends on what is loaded already, so the program finds out only when it starts.
In 2026 The base URL a page loads from, or the random base address ASLR picks.
Seen on DOS for developers
LZ77
A family of compression methods that stores each piece of data either as itself or as “copy this many bytes from that far back”. DIET packs his programs with a method of this family.
In 2026 The heart of gzip and zip, and of every PNG image.
Seen on Every ByteDOS for developers
MZ header
The table at the start of every DOS .EXE file. It begins with the letters MZ and tells DOS how big the program is, where it starts, where its stack goes and where its fix-ups are.
In 2026 A package.json for a program. Every Windows .exe still begins with MZ.
Seen on Every ByteDOS for developers
Runtime library
Code the compiler adds to every program: start-up, files, memory, strings, numbers.
In 2026 The C standard library, shared by every program on the system instead of copied into each one.
Static linking
Building a library into each program that uses it, so the program runs with nothing else installed.
In 2026 Like bundling your npm dependencies into one file. Go and Rust programs usually ship this way.
Seen on Arabic Basmallah
Text mode (files)
A setting of the DOS C library that writes every line feed byte (0Ah) as two bytes, 0Dh 0Ah, the line ending DOS expects in text.
In 2026 Windows still does it: you open a file with 'b' to keep the bytes exactly as they are.

Screen and graphics

BGI
Borland Graphics Interface: Borland’s drawing library for C and Pascal. Lines, circles, fills and text, with a driver file such as EGAVGA.BGI for the card.
In 2026 The canvas 2D API: one drawing API, a driver underneath for each screen.
Seen on The Brave SunText Editor: Demo
Bit Mask register
A VGA setting with one bit for each of the 8 pixels in a byte. Only the pixels whose bit is 1 change on the next write.
In 2026 A per-pixel write mask, like a stencil.
Seen on ARABARTArabic BasmallahWINKEY
Bit planes
How 16-color VGA stores pixels: 4 layers of memory at the same address, each holding one bit of every pixel’s color.
In 2026 A modern framebuffer keeps each pixel’s whole color together, for example in 4 bytes.
Seen on Kemyam: Group NamesDOS for developersWINKEY
Chain code
A path stored as a start point plus one small number per step, each number a direction.
In 2026 The h, v and l commands of an SVG path, or a turtle in a kids’ coding app.
Seen on Digi-Test
EGA
IBM's 1984 color graphics card. Its mode 10h shows 640 × 350 pixels in 16 colors, kept as 4 layers of bits. VGA cards run EGA modes too.
In 2026 A framebuffer, but split into 4 one-bit layers, one per color bit.
Seen on Port Said IT DepartmentWINKEY
Map Mask register
A setting on the EGA and VGA graphics card that picks which of its four color layers the next write lands in. Set it to 1, 2, 4 or 8 and one write fills one layer.
In 2026 Like writing only the red channel of an image, or only its alpha.
Seen on Kemyam: Group Names
Run-length encoding
Storing a picture as runs, “start here and paint this many pixels”, instead of storing every pixel one by one.
In 2026 Still used in fax images, BMP files and many game sprite formats.
Seen on Kemyam: Group NamesWINKEY
Save-under
Copying the part of the screen behind a menu or dialog into memory before drawing it, then copying it back when it closes.
In 2026 canvas getImageData() and putImageData(); a window compositor keeps every window in its own buffer.
Seen on Text Editor: Demo
Set/Reset
A VGA setting that holds a color. When it is on, every write paints that color into all 4 bit planes at once.
In 2026 Like a GPU fill with one solid color.
Seen on ARABARTArabic BasmallahDOS for developersWINKEY
Sprite
A small picture drawn once, kept in memory, and copied to a new place on the screen every frame, so it travels across the screen.
In 2026 An image you drawImage onto a canvas, or a sprite in any 2D game engine.
Seen on The Brave Sun
Text mode
A screen mode where the card draws the letters itself. A program writes two bytes per cell, a letter and its colors, on a grid of 80 by 25.
In 2026 A terminal window, with the font built into the hardware.
Vertical retrace
The short pause while a CRT’s beam goes back to the top of the screen, about 70 times a second in VGA text mode. Programs watch port 3DAh for it and use it as a clock.
In 2026 VSync, and requestAnimationFrame in a browser.
Seen on Kemyam: Group Names
VGA
IBM’s 1987 graphics standard. His programs use its 640 × 480 mode with 16 colors, kept in four color planes.
In 2026 The graphics card and its framebuffer, years before GPUs.
Seen on DOS for developersText Editor: Demo
VGA Graphics Controller
A set of settings on the VGA card, reached through I/O ports 3CEh and 3CFh. They decide what one byte written by the CPU does to the 4 bit planes.
In 2026 The blend and write-mask state of a GPU pipeline.
Seen on Arabic Basmallah
VGA latches
Four hidden VGA registers that hold the last byte read from each bit plane. Read first, then write, and the pixels you did not pick keep their color.
In 2026 Like a read-modify-write on a texture: load, change only some pixels, store.
Seen on WINKEY
VGA palette
The table of 16 (or 256) colors a VGA card shows. A program can set any entry to any of 262,144 colors, and everything already drawn in that entry changes at once.
In 2026 A design token or a CSS custom property: change it in one place and every use follows.
Seen on The Brave Sun
Video memory
Memory on the graphics card that the processor sees at a fixed address: A0000h for graphics, B8000h for color text. Write a byte there and the screen changes at once.
In 2026 A canvas’s ImageData, where the numbers are the picture.
Seen on Kemyam: Group NamesDOS for developers
XOR drawing
Drawing by flipping the bits of the pixels already on screen. Draw the same shape twice and the screen is exactly as before, so a cursor never needs to remember what was under it.
In 2026 The canvas blend mode "difference"; cursors today are a separate layer the GPU adds on top.
Seen on Text Editor: DemoWINKEY

Arabic text

Arabic-Indic digits
The digits ٠١٢٣٤٥٦٧٨٩, used in Egypt and much of the Arab world. Numbers read left to right, even inside right-to-left text.
In 2026 Unicode U+0660 to U+0669.
Seen on ARABART: Demo
Arabic-keyboard encoding
Storing Arabic as the English keys that carry each Arabic letter on an Arabic keyboard. “gtk” means لفن, because g, t and k carry ل, ف and ن.
In 2026 Unicode text in UTF-8, typed through a keyboard layout. The layout and the stored text are now separate things.
Seen on ARABART: DemoARABART: EditorARABARTArabic Basmallah
Auto-shaping
Choosing the right form of each Arabic letter from the letters beside it: on its own, at the start, in the middle or at the end of a word. That is how the word joins up.
In 2026 What HarfBuzz does in every browser and phone when it draws Arabic.
Baseline
The invisible line that letters sit on. Joined Arabic letters meet along it.
In 2026 The same idea in every font, and in CSS as vertical-align: baseline.
Bidi (bidirectional text)
Text that mixes right-to-left Arabic with left-to-right numbers or English words. Each run reads in its own direction.
In 2026 The Unicode Bidirectional Algorithm orders the runs for you, in every browser and phone.
Seen on Career
Glyph
The drawn shape of one character, or of one form of it. An Arabic letter can need up to 4 glyphs: alone, at the start, in the middle and at the end of a word.
In 2026 The same word is used for the shapes inside every OpenType and TrueType font.
Seen on ARABART: Editor
Harakat
Small vowel marks above or below Arabic letters. Most everyday Arabic leaves them out.
In 2026 Unicode combining marks, placed by the font’s mark-positioning tables.
Joining type
Which sides an Arabic letter can connect on: the letter before, the letter after, both, or neither. Alef joins only the letter before it. Beh joins both.
In 2026 A Unicode property (Joining_Type) that shaping engines such as HarfBuzz read for every character.
Kashida (tatweel)
The joining stroke ـ that stretches an Arabic word without changing its letters: الفـــن instead of الفن. Calligraphers use it to fill a line.
In 2026 The Unicode character U+0640. Some layout engines add it to justify text.
Seen on ARABART: Demo
Ligature
Two or more letters drawn as one shape, such as lam-alef: لا. ARABART gives it its own key, b, as on an Arabic keyboard.
In 2026 An OpenType ligature, like the fi in a good font or => in a coding font.
OpenType shaping
How a modern font engine turns letters into glyphs. It reads each letter’s joining type, picks the start, middle, end or alone form from the font, and joins lam-alef into one shape.
In 2026 HarfBuzz does this inside Chrome, Firefox, Android and many other systems.

Code and tools

Assembly
The processor’s own instructions written as words, one line per instruction: mov, add, jmp. An assembler turns them into bytes.
In 2026 What any compiled language becomes in the end. WebAssembly’s text format reads much the same.
Seen on Kemyam: Group Names
Borland C++
Borland's C and C++ compiler for DOS, from 1991. It came with its own editor, debugger, graphics library and a set of ready-made container classes, all in one box.
In 2026 An all-in-one IDE and toolchain, like Visual Studio or JetBrains CLion.
Seen on Digi-Test
Busy-wait loop
A pause made by counting in a loop. The common way to time an animation on a DOS PC, where programs had the whole machine to themselves.
In 2026 setTimeout() and requestAnimationFrame(), tied to the clock.
Class
A C++ type that keeps data together with the functions that work on it. One class can build on another and replace some of its functions.
In 2026 The same idea in TypeScript, Java, C#, Swift and Kotlin.
Seen on Text Editor: Sample GUI
Container class library
Ready-made C++ containers that came with Borland C++: Array, SortedArray and friends, all built on one base class called Object.
In 2026 The C++ standard library’s std::vector, or JavaScript’s Array and Map.
Seen on Digi-Test
Dead store
A value written to a variable and then written again before anything reads it. The program runs the same either way.
In 2026 Compilers remove them for you while they optimize.
DEBUG
A small debugger that came with DOS. It can read code as assembly, step through it, and change bytes in memory or on disk.
In 2026 A hex editor and a command-line debugger in one small tool.
Disassembly
Turning a program’s bytes back into readable assembly. His source code is lost, so this site reads his programs this way.
In 2026 Ghidra or IDA, or the source maps of the web, in reverse.
Seen on About
DOSBox cycles
A DOSBox setting for how many instructions the emulated processor runs each millisecond. A low, fixed number makes an old program run at about the speed of an old PC.
In 2026 Like CPU throttling in the browser’s developer tools.
Emulator
A program that acts out a whole computer in software. Here, DOSBox built for the browser (js-dos) runs his programs on a 1990s PC.
In 2026 A virtual machine, or a game console emulator.
Seen on AboutEvery Byte
Event loop
The loop at the heart of an interactive program: wait for input, decide which part of the program should handle it, call that part, repeat.
In 2026 Every browser runs one; all JavaScript runs inside it.
Seen on Text Editor: Sample GUI
Floating-point emulator
Code Borland added to a program to do the math chip’s work in software on PCs without one. The compiler marks every decimal operation, and at run time the emulator either does it in code or hands it to the real chip.
In 2026 Software floating point on small microcontrollers that have no hardware for decimals.
Seen on The Brave SunPort Said Computer Systems
Game loop
The loop that drives an animation: draw the frame, move everything a little, check the keyboard, go again.
In 2026 requestAnimationFrame in a browser.
Gap buffer
A text buffer that keeps an empty gap at the cursor. Typing fills the gap, so a keystroke moves almost nothing.
In 2026 How Emacs stores text.
Heap overflow
Writing past the end of a block of heap memory into the next one.
In 2026 Tools such as AddressSanitizer catch it, and memory-safe languages like Rust rule it out.
Inheritance
Building one class on top of another. The new class gets the parent’s data and methods, and can replace any of them with its own.
In 2026 class Button extends Component in TypeScript.
Inline assembly
Assembly instructions written inside a C or C++ function. The compiler writes the function’s first and last lines; the author writes the middle.
In 2026 Still possible with GCC asm blocks or Rust’s asm!, and still the way to reach the hardware directly.
Seen on ARABART: EditorPort Said Computer SystemsWINKEY
Interpreter
A small program that reads instructions in its own little language and carries them out one by one.
In 2026 The JavaScript engine in your browser and Python both work this way.
Seen on Port Said IT Department
Math coprocessor (8087)
A second chip that did math with decimals, such as sine and cosine, in hardware. Most PCs of the time did not have one.
In 2026 Built into every computer and phone processor today.
Obfuscation
Scrambling code or text so it reads as nonsense in the file, while the program unscrambles it as it runs.
In 2026 JavaScript minifiers and app protectors still do this.
Seen on Arabic CommercialTAHER
Opcode matching
Comparing two programs function by function, using only the order of their instructions and ignoring the addresses that change between builds. The same order means the same source code.
In 2026 Binary diffing tools such as BinDiff match functions between two builds the same way.
Seen on Text Editor: Sample GUI
Operator precedence
The rule that times and divide come before plus and minus, and brackets before everything, so 2 + 3 × 4 is 14, not 20.
In 2026 The same order JavaScript and every spreadsheet use.
PC speaker
The little beeper inside an IBM PC. It can only push its cone out or pull it in; a timer chip switches it back and forth fast enough to make a tone.
In 2026 A square-wave oscillator, the simplest sound a Web Audio page can make.
Piece table
A text buffer that never moves the original text. Edits are a list of pieces that point into the original file and into a buffer of everything typed.
In 2026 VS Code uses a version called a piece tree.
Seen on Text Editor: Demo
Project file
A file the IDE saves with the list of source files, folders and compiler options for one program. Borland used .PRJ for the project and .DSK for the windows left open.
In 2026 package.json or CMakeLists.txt, plus the editor’s saved workspace.
Seen on Text Editor: Demo
Self-modifying code
A program that writes new values into its own instructions while it runs, for example to change a color or a jump.
In 2026 Like setting shader uniforms before each draw call. JIT compilers in browsers write new code in a controlled way.
Seen on Arabic CommercialPort Said IT Department
Stack checking
A compiler option that adds a short test at the start of every function, so a stack about to run out stops with a clear message.
In 2026 The guard page an operating system puts below every stack.
Stack frame
How a C function finds its arguments: the caller puts them on the stack, and the function reads them from fixed places beside its return address.
In 2026 Every compiled language still does this; today the first few arguments usually travel in registers.
Seen on Port Said Computer Systems
State machine
Code that is always in one of a few states. Each input moves it to the next state, and the state decides which inputs it accepts.
In 2026 The idea behind form wizards, UI flows and network protocols.
Thread
A separate line of work inside one program. Two threads run at the same time, so a program can print in the background while you keep typing.
In 2026 Still the same. Async code and worker pools run on threads.
Seen on Career
Tokenizer
The first step in reading a formula or a program: it cuts the text into pieces such as numbers, names and signs.
In 2026 Every compiler, JSON parser and syntax highlighter starts with one.
Turbo C / Borland C++
Borland’s C and C++ tools for DOS: a blue full-screen editor, compiler and debugger in one program. Yasser wrote his C programs in it.
In 2026 An IDE such as VS Code with the compiler and debugger built in.
Seen on Port Said Computer SystemsWINKEY
Turbo Debugger
Borland’s full-screen debugger. It steps through a program one line at a time and shows the registers, the stack and memory.
In 2026 The Sources panel of browser DevTools, with breakpoints and watches.
Virtual method
A method each subclass can write its own way. The program calls it through a table, so one line of code works for every kind of object.
In 2026 A method declared in a TypeScript interface, or a trait method in Rust.
Virtual method table
A table of function addresses that C++ makes for each class with virtual methods. Each object starts with a pointer to its table, so one call finds the right function for any kind of object.
In 2026 Still how C++ works, and how Rust calls methods on trait objects. JavaScript’s prototype chain plays the same role.
Seen on Digi-TestText Editor: Sample GUI

Numbers

BCD
Binary-coded decimal: each decimal digit stored on its own, so money-style sums come out exact, with no binary rounding.
In 2026 Decimal types: Python’s Decimal, Java’s BigDecimal, SQL’s NUMERIC.
Checksum
One number made by adding up a block of bytes. Change any byte and the total changes, so a program can tell its code was touched.
In 2026 The same idea as a file hash, or the integrity hash on a script tag.
Fixed point
Numbers with a set count of digits after the point, worked out with whole-number math.
In 2026 Storing money as cents in an integer.
Ten's complement
A way to keep negative numbers without a minus sign, like a car’s odometer rolled back past zero: 0000 minus 1 shows 9999. Each digit becomes 9 minus itself, then 1 is added. Subtracting then becomes plain adding.
In 2026 Every CPU today does the same thing in binary, called two's complement.

Digital circuits

ATPG
Automatic test pattern generation: software that works out the inputs that reveal a circuit’s faults.
In 2026 A standard step in chip design, done by tools such as Synopsys TestMAX and Siemens Tessent.
Controlling value
The input value that decides a gate on its own: a 0 settles an AND or a NAND, a 1 settles an OR or a NOR.
In 2026 Short-circuit evaluation: false && anything is false, true || anything is true.
Seen on Digi-Test
D-algorithm
J. Paul Roth's 1966 method for finding a test pattern for a broken pin. It marks the fault as D or D̄ and searches for inputs that carry the mark to an output, stepping back when it hits a dead end.
In 2026 Its descendants, PODEM and FAN, run inside today’s chip test tools.
Seen on Digi-Test
Fault dictionary
A table made in advance: for each test pattern, which broken pin changes which output. Match a real board’s answers against it to name the fault.
In 2026 Like matching an error signature against a list of known causes.
Seen on Digi-Test
Five-valued logic
Logic with five values instead of two: 0, 1, X (not known yet), D (1 if the chip works, 0 if it is broken) and D̄ (the opposite). One pass follows a fault through the whole circuit.
In 2026 Verilog simulators use a cousin: 0, 1, X and Z.
GPIO
General-purpose input and output: pins of a small chip that software can set to 0 or 1, or read.
In 2026 Arduino's digitalWrite() and digitalRead().
Guided probe
A repair method where the program tells the technician where to touch next. It walks back from a wrong output until it finds the part that turns good inputs into a bad output.
In 2026 Still used in board repair; boundary scan (JTAG) now reads many of the same points from software.
Seen on Digi-Test
ISA card
A card for the expansion slots of the IBM PC and AT. The program reaches it at numbered I/O ports; IBM kept ports 300h to 31Fh free for home-made cards.
In 2026 PCI Express replaced ISA. For a home-made board, USB and an Arduino do the job.
Logic gate
A tiny circuit that answers AND, OR, NOT, NAND or NOR for its inputs. Every input and output is a 0 or a 1.
In 2026 The && and || of a program, built in hardware. A modern CPU holds billions of them.
Logic simulator
Software that works out, gate by gate, what a circuit will output for given inputs.
In 2026 Logisim for teaching; Verilator and Icarus Verilog for real chip designs.
Netlist
The list of which pins connect to which: the circuit with the drawing taken away.
In 2026 What KiCad and every chip design tool produce for the factory.
Open-collector output
A chip output that can only pull a wire down to 0. Several of them can safely share one wire.
In 2026 The open-drain pins of a microcontroller, and the wires of the I2C bus.
Seen on Digi-Test
Stuck-at fault
The standard way to describe a broken chip: one wire stuck at 0, or stuck at 1, whatever the circuit tries to put on it.
In 2026 Still the basic fault model in chip testing.
Seen on Digi-Test
Test pattern
One set of input values for a circuit. A good pattern makes a broken circuit give a different answer from a working one.
In 2026 Chip makers run thousands of generated patterns on every chip they ship.
Seen on Digi-Test
Truth table
Every combination of a circuit’s inputs, with the output for each one. A circuit with n inputs has 2ⁿ rows.
In 2026 Like a table-driven unit test that lists every case.
Seen on Digi-Test
TTL (74xx chips)
The 7400 family of logic chips. A 7400 holds four 2-input NAND gates in a 14-pin package; pin 7 is ground and pin 14 is the +5 volt supply.
In 2026 Still sold for teaching and repair. New designs put the same gates inside an FPGA or a custom chip.
Seen on Digi-Test

Viruses and defense

Behavior detection
Spotting a virus by what it does, such as rewriting many programs, instead of by bytes it carries. It can catch a virus nobody has seen before.
EDR
Endpoint detection and response: security software on each computer that watches what programs do, raises alerts and can stop or undo an attack.
File infector
A virus that copies itself into programs. It changes where each program starts so the virus runs first, then hands control back so nothing looks wrong.
In 2026 Like a supply-chain attack that slips code into a package, then lets the package work as usual.
Virus signature
Bytes that only one virus has, at known places in a file. Find them and you know exactly which virus you have.
In 2026 Antivirus definitions and YARA rules are long lists of signatures.

Phones and apps

Hijri calendar
The Islamic calendar. Each month starts with the new crescent moon, so a year has about 354 days.
In 2026 Built into every browser: Intl.DateTimeFormat with the islamic-umalqura calendar.
Pocket PC / Windows Mobile
Microsoft’s system for handheld computers and, later, smartphones, from 2000 to about 2010. Apps were installed from small CAB files.
In 2026 iOS and Android took its place.
Shareware
Try before you buy. The full program runs for a trial period (15 days for DinarSoft), then asks for an unlock key that you buy from the maker.
In 2026 A free trial, or a free app with an in-app purchase.
Today screen
The home screen of a Pocket PC. Small plug-ins each added one line to it: the date, your next meeting, new messages.
In 2026 Home-screen widgets on iOS and Android.

Networks

Ansible
An open-source automation tool. It runs ordered tasks on many machines or network devices, often filling Jinja templates to make their settings.
CLI (command line)
Typed text commands to a device. Each router maker has its own commands, and they can change from one software release to the next.
Seen on Patents
CMIP
The telecom industry’s own protocol for reading, changing, creating and deleting the parts of a network, and for receiving their alarms.
In 2026 NETCONF or gNMI, with data described in YANG.
Seen on CareerPatents
CORBA
A 1990s standard for calling a method on an object that lives in another program, on another machine, written in another language. One interface file describes every call.
In 2026 gRPC does the same job today. A REST API with an OpenAPI file is its looser cousin.
Seen on CareerPatents
Event channel
A middleman for events. A sender puts an event in once; the channel hands a copy to every receiver that listens. Senders and receivers never need to know each other.
In 2026 A Kafka topic, or a pub/sub topic in the cloud.
Seen on Career
GDMO
The telecom notation that describes one kind of equipment: what you can read, what you can set, what it can do, and which alarms it sends.
In 2026 A YANG module.
Seen on Career
IDL
Interface Definition Language: a small file that lists an interface’s calls and data types, and nothing else. A compiler turns it into client and server code for C++, Java and more.
In 2026 A .proto file for gRPC, or an OpenAPI file for REST.
Seen on Career
IP subnet
The /16 in 10.1.0.0/16: the first 16 bits name the network, the rest name machines inside it. “Is this address in that network?” is one comparison on a 32-bit number.
Seen on Patents
JIDM
Joint Inter-Domain Management: a set of rules for turning telecom’s own equipment descriptions into CORBA interfaces, and for translating calls between the two while the system runs.
In 2026 Code generated from a schema, plus a gateway between two protocols, such as grpc-gateway.
Seen on Career
Jinja
A Python template language: text with {{ blanks }} that becomes a finished file when you fill in the values. Ansible uses it to write device settings.
Managed object
The software view of one part of the network, such as a shelf, a card or a port. It has settings you can read and change, actions you can run, and events it reports.
In 2026 One node in a YANG data tree.
Seen on Career
NETCONF
A protocol to read and change a device’s settings as structured data, all at once: the whole change is applied, or none of it.
Network manager (NMS)
The control-room software for a whole network of switches and routers. It keeps the inventory, shows the alarms and sets up connections.
In 2026 A network controller, with telemetry and alarm dashboards.
Seen on CareerPatents
ORB
Object Request Broker: the CORBA library inside each program. It finds the remote object, packs the call into bytes, sends it over the network and unpacks the answer.
In 2026 The gRPC runtime and the code it generates.
Seen on Career
OSS
Operations support system: a phone company’s own back-office software for orders, billing, inventory and faults. It tells the network managers what to do.
In 2026 Still called OSS/BSS. Modern ones talk to the network over REST or gRPC.
Seen on CareerPatents
OSS interface
The published door in a network manager that a phone company’s own systems use to read alarms and inventory and to order changes.
In 2026 The public API of a network controller.
TL1
Transaction Language 1: a plain-text command language for telecom equipment.
Seen on Patents
TMN
Telecommunications Management Network: the international framework for running telecom networks in layers, from single devices up to services and business.
In 2026 Operators still use its layer names.
Webhook
A call that a service makes to your URL when something happens, so you never have to keep asking.
Seen on Patents
YANG
The language that describes a device’s settings and state as a typed tree. NETCONF, RESTCONF and gNMI all carry data described in YANG.

Databases and patents

Claim (patent)
The numbered sentences at the end of a patent. They say exactly what the patent protects; the rest of the text explains and gives examples.
Seen on Patents
Closure table
An extra table with one row for every ancestor and descendant pair. “Everything under X” is one lookup on the ancestor column.
DynamoDB
Amazon’s managed key-value database. Each item has a partition key and an optional sort key, and inside one partition the items are kept in sort-key order.
Seen on Patents
Foreign key
A column that holds another row’s key, to say “this belongs to that”. A reply can hold the id of the comment it answers; a port can hold the id of its card.
Seen on Patents
hierarchyid
A SQL Server data type that stores a row’s place in a tree in a short binary form. Sort by it, and each branch sits together.
Index (database)
A sorted copy of a column with pointers back to the rows, usually a B-tree. The database jumps straight to a value, or to the start of a range, without reading the whole table.
Seen on Patents
Join
A SQL step that matches the rows of two tables on a key. Following a chain of parents (port to card to shelf) takes one join for each step.
ltree
A Postgres data type for paths such as n5.s2.sl3. The <@ operator means “is inside”, and a GiST index answers it fast.
Seen on Patents
Materialized path
Storing the full path from the top in each row as text, such as /5/2/3/. “Everything under /5/2/” is then a prefix search on an index.
Seen on Patents
Nested sets
Numbering a tree by walking around it: each row gets a left and a right number, and every row inside it gets numbers between those two.
ORDPATH
A way to label the nodes of a tree so the labels sort in tree order and always leave room to insert a new node between two others. SQL Server’s hierarchyid is built on it.
Primary key
The column whose value names one row and no other row in its table, like a user id.
Prior art
Everything published before a patent was filed. A patent covers what is new compared with it.
Range scan
Reading an index from a start value to an end value. The index is sorted, so every match sits in one unbroken stretch: one jump, then read forward.
Seen on Patents
Recursive query
A SQL query (WITH RECURSIVE) that repeats a join until it reaches the bottom of a tree. You write it once, but the database still works one level at a time.
Seen on Patents
Relational database
Data kept in tables of rows and columns. Rows in different tables are linked by matching keys, and you ask questions in SQL.
In 2026 PostgreSQL, MySQL, SQL Server and SQLite all work this way.
Seen on Patents
Sort key
In DynamoDB, the second part of an item’s key. A query can read a range of sort keys, or every sort key that begins with a prefix.
Seen on Patents

More words

ActiveSync
Microsoft’s desktop program that connected a Pocket PC to a Windows PC by cable or cradle, to sync mail and contacts and to install apps from the PC.
In 2026 Plugging an iPhone into a computer to sync it, or the phone link apps of today.
ARM processor
The low-power chip family inside Pocket PCs (StrongARM and XScale). DinarSoft’s programs are ARM machine code: 4-byte instructions that work on 16 small slots inside the chip, named r0 to r15.
In 2026 The same family runs every phone today, and Apple’s M-series Macs.
BitBlt
The Windows call that copies a rectangle of pixels from one picture to another. A rule called a raster operation mixes the two: copy, AND, OR, XOR and more.
In 2026 drawImage on a canvas with globalCompositeOperation.
BMP file
The Windows picture format: a 14-byte file header, a 40-byte picture header, then the color of every pixel, row by row from the bottom.
In 2026 Still opened by every browser and image viewer. PNG does the same job, compressed.
C++ class
A type that bundles data with its own functions. Classes that share one set of virtual functions can be called the same way, each doing its own thing.
In 2026 An interface with several implementations, in Swift, Kotlin or TypeScript.
CAB file
The install package of a Pocket PC app: one compressed file with the program, its settings and where each part goes. Tap it on the device and it installs itself.
In 2026 An .apk on Android, or an app download from a store.
CAB file
The installer package of Windows Mobile: a compressed archive of the program’s files, plus a setup DLL that runs on the device during the install.
In 2026 An .ipa on iPhone or an .apk on Android.
CAB installer
The install package for a Pocket PC: the program files plus a small list of where each one goes and what to add to the registry.
In 2026 An APK on Android or an IPA on iOS.
Clipboard
The shared place where Copy puts text and Paste takes it from, open to every program.
In 2026 The same clipboard, on every phone and computer.
Control panel applet
One page of Settings, kept in its own file. Pocket PC opened a page when a program started ctlpnl.exe with the page number on its command line.
In 2026 A deep link into Settings: ms-settings:dateandtime on Windows, a Settings intent on Android.
Device Emulator
Microsoft’s free program that runs a whole Pocket PC inside a window on a Windows PC, with its screen, buttons and storage card.
In 2026 The Android Emulator in Android Studio, or the iOS Simulator in Xcode.
Device ID
A number burned into each Pocket PC that the system hands out when asked (the IOCTL_HAL_GET_DEVICEID request). Shareware turned it into a code the buyer could read out to the seller.
In 2026 A hardware fingerprint, like the identifier an app store uses to tie a license to one phone.
Device ID
A number burned into each Pocket PC that tells it apart from every other one. Programs read it with one system call, KernelIoControl.
In 2026 identifierForVendor on iPhone, ANDROID_ID on Android.
Device ID
A number the Pocket PC’s maker burned into each device. MemMaid read it with KernelIoControl and turned it into the 16-letter code on its License Key screen.
In 2026 identifierForVendor on iOS, ANDROID_ID on Android.
DHCP
How a device borrows an address on a network: it asks, the network’s server offers one, the device accepts, the server confirms. The address is lent for a set time.
In 2026 Exactly the same today. Your home router is the DHCP server for every phone and laptop in the house.
Dialog template
A description of a window stored inside the program file: each control, its kind, its words and its position in dialog units. Windows builds the window from it when the program asks.
In 2026 A JSON layout file, or an Android layout XML, that the app inflates into a screen.
Dialog template
A screen’s layout stored as data inside the program: every label, box and button with its position and size. Windows builds the screen from it at run time.
In 2026 An Android XML layout or a SwiftUI view description.
DLL
A dynamic-link library: a file of code that another program loads and calls. HijriDate is one DLL that the Today screen loads.
In 2026 A shared library: a .dylib on a Mac, a .so on Linux, a module a host app imports.
DLL
A dynamic link library: code that many programs share, loaded when one asks for it.
In 2026 A .so file on Android and Linux, a .dylib or framework on Apple systems.
Focus
The box that gets what you type, the one with the blinking cursor. Windows answers “which box has the focus?” only for the program that owns it.
In 2026 document.activeElement in a web page.
Function table (.pdata)
A list inside every Windows Mobile program file with the start and length of each function. The system reads it to unwind the call stack after an exception, and it also lets anyone count and compare its functions exactly.
In 2026 A table of contents for the compiled code, like the symbol list a bundler prints for a JavaScript build.
Heap compaction
Tidying a program’s working memory: blocks in use move together, and the free pages between them go back to the system.
In 2026 What a garbage collector does after it frees objects in Java, C# or JavaScript.
Hijri calendar
The Islamic calendar. Its 12 months follow the moon, so a year is about 354 days. A month starts when the new crescent is first seen after sunset. Years count from the Hijra, the Prophet’s move from Mecca to Medina in 622.
In 2026 Still the calendar for Ramadan, the two Eids and the Hajj. Every browser ships it: Intl.DateTimeFormat with calendar islamic-umalqura.
Input panel
The small keyboard a Pocket PC drew at the bottom of the screen, tapped with a stylus. It could also read handwriting.
In 2026 The on-screen keyboard of a phone.
Julian day
A plain count of days since noon on 1 January 4713 BC. Astronomers use it so that any two dates subtract into a number of days, with no months or leap years in the way.
In 2026 A Unix timestamp, counted in days instead of seconds.
Jump table
A list of addresses, or distances, that a switch statement can compile into. The program reads one row and jumps there, instead of testing every case in turn.
In 2026 Compilers for C, Rust and Go still build one for a dense switch or match.
Kernel mode
The level the system itself runs at, with access to all memory. SetKMode let a Windows CE program step up to it for a moment.
In 2026 Root access, or a kernel driver. Phones keep it from apps today.
KernelIoControl
A Windows CE call that sends a numbered command straight to the lowest layer of the system, the code written for that device’s chips. HandyMenu uses it to restart the device.
In 2026 ioctl() on Linux, or a phone’s system API that only system apps may call.
Key engine
The function the three Handy apps share that turns a 16-letter code into a 16-letter key. It shuffles 120 numbers using the product name, the way the RC4 cipher shuffles 256, then mixes each letter with the shuffle.
In 2026 A keyed hash, like an HMAC: the same input gives the same output, and the key (here the product name) changes everything.
Loader
The part of the system that finds a DLL when a program asks for one, and maps it into memory. It looks in a fixed list of folders, in order.
In 2026 The PATH and library search path on any computer today.
Loading a function at run time
Asking the system for a function by name while the program runs (LoadLibrary, then GetProcAddress), so the program still starts on a device that lacks it.
In 2026 Feature detection in JavaScript: if ("share" in navigator), or a dynamic import().
Looking up a call at run time
Asking the system for a function by its name while the program runs, instead of linking to it in advance. If the device is too old to have it, the program carries on without it.
In 2026 Feature detection in JavaScript: if ("share" in navigator) { … }.
Macro
A placeholder in saved text that TapText fills in as it types. {{DATE:…}} gives the date in a chosen format and {{TIME:…}} the time. {{TAB}} jumps to the next box, and {{CTRL-B}} turns on bold.
In 2026 Template variables, like {{date}} in a text expander or an email template.
Main memory
The Pocket PC’s RAM. On Windows Mobile 2003 one chip held both your files and your running programs, so every byte of junk took room from the apps.
In 2026 The RAM in your phone. Files moved to flash storage from Windows Mobile 5 on, as they live on a phone today.
Memory division
On Windows Mobile 2003, the line between RAM for files and RAM for programs. The system moved it by itself; MemMaid let you set it.
In 2026 Nothing like it today: storage and memory are separate chips.
New moon
The moment the moon passes between the Earth and the sun, so its lit side faces away from us. A few hours to a day later, a thin crescent can be seen just after sunset.
In 2026 Astronomy apps print it to the minute.
Notification queue
The system’s list of programs to start at a set time or on an event, such as a sync, a card going in, or the device waking up.
In 2026 AlarmManager and WorkManager on Android, BGTaskScheduler on iOS.
Owner-drawn menu
A menu that the program paints itself, item by item, instead of letting Windows do it. That is how HandyLauncher’s menus got their icons and their own colors.
In 2026 A custom right-click menu built with HTML and CSS instead of the browser’s plain one.
Owner-drawn menu
A menu whose items the program paints itself, so it can add icons and its own colors to an ordinary system menu.
In 2026 A custom context menu in a web app, drawn with your own HTML and CSS.
PerformCallBack4
A Windows CE system function that runs a function inside another process, as if that process had called it. MemMaid used it to send its helper into each app.
In 2026 No store app may do this today. Debuggers and tools like Frida do.
Posting a message
Dropping a message into another window’s queue and moving on, without waiting. Programs on Windows talk to each other this way.
In 2026 window.postMessage between browser tabs and iframes.
Process
One running program, with its own memory. Windows CE gave each process a slot of 32 MB, and a program could not normally see into another’s.
In 2026 Every app on a phone runs in its own process, in its own sandbox.
Raster operation
The rule BitBlt uses to mix source pixels with the pixels already there, bit by bit. AND keeps a pixel only where both are on, OR turns it on where either is on, XOR flips it.
In 2026 Blend modes and compositing operators in CSS and canvas, such as multiply, screen and xor.
RC4
A famous cipher from 1987: shuffle a deck of 256 numbers with a password, then keep swapping cards and dealing one out for each byte. DinarSoft’s key engine uses the same deal-and-swap idea with a deck of 120.
In 2026 RC4 once protected Wi-Fi (WEP) and HTTPS. Today ChaCha20 does that job.
RC4
A simple, famous cipher from 1987: shuffle a table of numbers with a key, then walk the table to make a stream of numbers to mix into the text. DinarSoft’s key function is built the same way, with 120 numbers.
In 2026 Retired from Wi-Fi and HTTPS. The idea of a keyed shuffle lives on in every stream cipher.
REG_MULTI_SZ
A registry value that holds a list of strings as one block: each string ends with a zero, and one more zero ends the list.
In 2026 A list in a JSON settings file.
Registry
The settings database every Windows and Windows Mobile program shares, organized in folders called keys. HandyLauncher keeps each menu item there as a small group of values.
In 2026 localStorage in a browser, or the defaults database an app writes on a Mac.
Registry
The system-wide settings store on Windows: keys like folders, holding named values. Every program keeps its settings there.
In 2026 A key-value store for the whole system, like macOS defaults or localStorage for every app at once.
Registry
The Windows settings database: a tree of keys and values. Programs save their options and their unlock keys there.
In 2026 UserDefaults on iPhone, SharedPreferences on Android, localStorage in a browser.
Registry
The settings store of Windows and Windows Mobile: keys like folders, values like files, shared by the system and every app.
In 2026 Settings and SharedPreferences on Android, UserDefaults on iOS, but one app at a time.
Registry
The Windows settings database: a tree of keys and values that every program can read and write.
In 2026 UserDefaults on iPhone, SharedPreferences on Android.
Salt
A small, fixed change mixed into stored data, so the bytes on disk never match the plain values they hide.
In 2026 The salt added to a password before it is hashed.
Screen orientation
Which way up the screen is drawn. Windows Mobile 2003 SE and later could turn the picture 90, 180 or 270 degrees, so a Pocket PC could be held sideways.
In 2026 A phone turning its screen when you turn it, or an app locking itself to landscape.
SHA-256
A fingerprint of a file: 64 characters computed from every byte. Change one byte and the fingerprint changes completely, so a match proves the file is identical.
In 2026 The checksum next to a download, or the integrity hash in a package-lock.json.
ShellExecuteEx
The Windows call that opens anything by its name: a program, a document, a song. Windows looks up which program handles that kind of file and starts it.
In 2026 The open command on a Mac, or tapping a link in a browser: you name the thing, the system picks the app.
Shortcut file
On Windows Mobile a .lnk file is a line of plain text: the length of the command, a # sign, and the command. 21#\Windows\poutlook.exe starts Outlook.
In 2026 A .desktop file on Linux, or an alias on a Mac.
Soft reset
Restarting a Pocket PC. Programs close and start fresh; your files stay.
In 2026 Restarting your phone.
Software floating point
The phone’s ARM chip had no hardware for decimal fractions. So every add or multiply of a double was a call into a small library in the system (__addd, __muld).
In 2026 What a JavaScript engine does on a chip with no float unit. Phones today all have one.
StartUp folder
A folder, \Windows\StartUp, that Windows Mobile reads at every start. Each shortcut in it runs.
In 2026 Login items on a Mac, startup apps on Windows.
String table
Every word a program shows, in one numbered list. The code asks for string 675; the table says “Quick Cleaner”.
In 2026 The strings files that apps translate, one per language.
Subclassing a window
Swapping in your own message handler for another window’s, keeping the old one, and passing on every message you do not handle.
In 2026 Monkey-patching a function, or a middleware that wraps a handler and calls next().
Tap and hold
Keeping the stylus on the screen for a moment instead of lifting it. Windows Mobile draws a ring of red dots while it waits, then treats it as a second kind of tap.
In 2026 A long press on a phone, which opens a menu instead of the app.
Tap and hold
The Pocket PC’s right-click: keep the stylus on the screen and a ring of red dots fills in. When it closes, the program does its second action.
In 2026 A long-press on a phone.
Tap and hold
Windows Mobile’s right click: keep the stylus still and a ring of red dots fills in, then a second menu opens.
In 2026 A long press on a phone.
TerminateProcess
Ends a program at once, from outside, without asking it. The system takes back its memory.
In 2026 kill -9, or Force Quit on a Mac.
Today plug-in
A small DLL that adds a panel to the Today screen. The Today screen loads it, gives it a strip of the screen, and asks it every two seconds whether it needs to redraw.
In 2026 A home screen widget: WidgetKit on iPhone, an App Widget on Android.
Today screen
The home screen of a Windows Mobile Pocket PC: one column of small panels for the date, mail, tasks and appointments. Other programs could add their own panel to it.
In 2026 The home screen of a phone, with its widgets.
Trackbar
The Windows name for a slider control. A program sets its range and can mark a band on it.
In 2026 An HTML range input.
Tray
The strip of small icons in a corner of the Pocket PC screen, where programs that run in the background show themselves. Tap one to talk to its program.
In 2026 The menu bar icons at the top right of a Mac, or the icons next to the clock on Windows.
Tray icon
A small icon a program puts at the bottom of the Pocket PC’s Today screen, so it is one tap away while it waits in the background.
In 2026 A menu bar extra on a Mac, or a quick-settings tile on Android.
Window procedure
The one function that handles every message a window gets: taps, key presses, “please close”, “repaint”. Windows calls it for each message, one at a time.
In 2026 An event handler, like a single addEventListener that receives every event.
Window procedure
The one function that receives every message sent to a window: taps, keys, paint requests. Swap it, and you decide what happens to those messages.
In 2026 An event handler; swapping one is like wrapping a function in JavaScript.
Windows Mobile
Microsoft’s system for pocket computers and smartphones, from 2003 to 2010. Before 2003 it was called Pocket PC. Programs were written in C and C++ against a small version of the Windows API.
In 2026 What Android and iOS are today.
Windows Mobile service
A DLL that services.exe loads at startup and keeps running in the background. It has a short three-letter prefix (HandySwitcher’s is HSW) and its settings live in the registry under Services.
In 2026 A launchd daemon on macOS or a systemd service on Linux.
WM_CHAR
The message Windows sends a window for each character typed. A program can post the same message itself, and the window cannot tell it from a real key press.
In 2026 A synthetic input or keypress event.
WM_CLOSE
The polite request to close a window. The program can save its work first, ask a question, or ignore it.
In 2026 SIGTERM on Linux and macOS, or a “beforeunload” in the browser.
WM_HIBERNATE
The message Windows Mobile sends an app when memory runs low. A well-made app answers by letting go of what it can rebuild later: pictures, caches, hidden windows.
In 2026 onTrimMemory on Android, didReceiveMemoryWarning on iOS.