Dictionary of Terms · Geography Programming Courses

This is a brief dictionary of terms used in our various courses. For fuller details, click the word, which will link to more information.

Abstraction: The degree to which a computing language hides the complications of how the underlying computing hardware works when allowing a programmer to solve a particular problem or adjust the computer in some way. Although most languages (especially third generation languages) still require programmers to think through a sequence of tasks, the highest level of abstraction would be for a computer to automatically find the solution to issues or prempt adjustments.
Access control: Code to control access to the variables and procedures inside objects. Often centres on keywords such as "public" or "private", which limit whether other classes of object can or can't use the variables or procedures.
Accessor method: A procedure for getting the value of a variable inside an object. Often called a "getter", as generally such procedures are named "get" and then the variable name. Often associated with direct access to the object being limited through access control.
Algorithms: A comprehensive description of the pathway to gain a result. This may be enacted in code, but generally is written in pseudocode first. In general algorithms should be decided on prior to coding. Well known algorithms are distributed as exemplar solutions similar to patterns, the distinction being one of scale – algorithms deal with a series of statements whereas patterns deal with overall code structure.
All caps / Screaming snake case: All caps is the format of writing everything in capitals, e.g. ALL CAPS. Screaming snake case is a commonly used format for variables (mainly 'constants' that you don't expect to change) where all caps are linked with underscores, e.g. SCREAMING_SNAKE_CASE. It is named after the more common snake_case. Alternatives include camelCase, snake_case, and PascalCase. See case styles.
Anti-patterns: Anti-patterns, in contrast to patterns, detail poor ways of dealing with issues as warnings, though these are sometimes more controversial than patterns.
Applications: A piece of software, like a word processor, that provides services to users. c.f. systems.
Application Object: A gateway into the objects that make up an application in some kinds of applications that allow extension scripting.
Application Programming Interface (API): A set of ways of interacting with code, usually generated by other people, and the associated documentation (which is often also called the API). Classically, this is via calls to procedures inside objects within libraries.
Arguments: Values passed into a program or procedure. These are usually used to set parameters within the code.
American Standard Code for Information Interchange (ASCII): A character encoding used to represent human language characters (principly English) in binary, for example 1000001 (decimal 65) was "A". ASCII forms the foundation of most subsequent, more international, character sets.
Assembly code / Assembler: Human readable shortcuts mapping, or closely mapping, onto the machine code instructions which control a computer. These short names are converted into the equivalent binary code to run.
Assignment: The process of attaching an identifying label to a value; e.g. a = 10; to create a variable with a value.
Asynchronous programming: A variety of coding structures where, rather than the program running from beginning to end as it is written in a file, the code execution splits, with some elements waiting for a signal to run. Associated with, for example, callbacks and event based programming.
Atom: In languages, the smallest units with meaning, for example, a variable name or keyword; the building blocks of a language.
Binary Code: Binary code can be represented as one and zeros, but is essentially the encoding of a sequence of on and off electrical pulses which control the computer. Ultimately all code resolves to such sequences. Binary code is still at the heart of the machine code that operates computers, but is also used in some data storage formats such as image formats.
Block: A unit of code where a variable has scope. This is usually marked by punctuation.
Braces: {} Sometimes known as curly brackets.
Brackets: [] Sometimes known as square brackets.
Buffer: A buffer is a portion of memory which temporarily stores data being sent to or received from an external device, such as a keyboard. A buffer can sit between two devices that have different speeds for handling data. This provides a more consistant data stream and prevents hardware issues.
Bug: An issues with code. Generally bugs are divided into syntax or other issues that stop code compiling and issues with program logic that cause it to fail when running. A large part of being a programmer is debugging.
Bytecode: An intermediate code between source code and machine code. Such code is often run on a virtual machine/runtime environment which runs machine code when it meets a bytecode instruction. Sometimes (e.g. in Java) bytecode can be produced and distributed for running multiple times (in which we might talk of compiling the source to bytecode and then the bytecode being interpreted), or (e.g. in Python) produced once as part of an interpreter run.
Callback: A widely adopted functional programming form in which a procedure is passed into another, with the assumption that at some point the second procedure will run the first, potentially passing in arguments like data.
Camel case: Camel case is the practice of writing compound words or phrases without intervening spaces or punctuation, starting each word with a capital letter, e.g. camelCase. The difference of having a lower case start is enough to mark it out from PascalCase. Alternatives include snake_case, SCREAMING_SNAKE_CASE, and PascalCase. See case styles.
Class: In Object Orientated Programming a class is an extensible programming template for creating objects which represent real world entities. A class may provide variables and proceedures for instances.
Class variable: A variable defined as associated with a class, for example by being declared within the class but outside of any procedure. Such variables can often be accessed directly from the class without first turning it into an object. Also known as "class attributes".
Client-server architecture: A common architecture for systems on the internet, including the web. A piece of "client" software on one machine talks to "server" software on another, which sends it data that it "hosts". In general, each server can serve several clients symultaneously. A more generic version is the n-tier architecture.
Code Repository: A location for storing code. Often these include services for allowing a team to work symultaneously on the code, resolving conficts. Often they are also are public, as part of an Open Source effort. Finally, they may also include facilities for version control.
Cohesion: Cohesion is the purity of purpose of the class; the degree to which it focuses on a single clear task. High cohesion leads to more reusable and easier to understand code.
Communication protocol: A standard for constructing and handling communications between machines, for example over the internet. Examples include TCP/IP.
Coupling: Coupling is the degree to which two classes 'know about each other', that is, the degree to which they utilise each other's internal code. High coupling is generally regarded as a bad thing, encouraging side effects and reducing the reuseability of code. Ideally, classes should communicate through their APIs.
Comment: A comment is a human-readable explanation or annotation of the source code of a program.
Concurrent programming: The splitting of a program into dissimilar parts that run symultaneously to achieve an aim, for example on a multi-core chip machine. Contrast with the similar parallel programming which tends to split programs into similar parts that run on multiple machines.
Constructor: A procedure specifically for creating and/or initalising an object. There is often a special way of calling such a procedure during instantiation.
Control scripting: Script production to manage or organise systems, for example file systems and software installations.
Command-line interfaces / command prompt / terminal: An interface through which users interact with software. On windows computers this is generally called a command prompt (though this is formally the actual input point); on Linux this is generally called a shell or shell prompt (though the shell is formally the software you're interacting with); on Macs, this is generally called a terminal (though terminals are more generally a text interface to a system which may be elsewhere). Command-line interfaces generally contrast with GUIs.
Compiler: Converts one programming language into another; usually high level language into a low level language like machine code. Generally, when people talk about a compiler informally (which we do) they talk about something that produces a piece of code that will then run multiple times without recompiling. This is because modern IDEs disguise a lot under a single compilation button. In reality, compilers do one stage in the process of producing code that runs (for example, a "linker" is often needed to join compiled code together).
Component Object Model (COM): An interface based inter-process communication system at the heart of Microsoft software and systems. Used to, for example, allow data from one application to be cut and pasted into another.
Computational thinking: The art and science of thinking in a way that allows a problem to be tackled by a computer. Computational thinking centres on a logical approach that breaks issues down into smaller component parts and orders attempts on them such that they are possible, but also includes issues like pattern recognition (have I seen something like this issue before), decomposition (what are the sub-problems here), and abstraction (what are the general ways people solve these types of issues).
Condition: An expression that usually controls the control flow by evaluating to either "true" or "false". Generally conditions compare two things (e.g. "is variable A equal to some value?"), but may embed these comparisons within Boolean logic (e.g. "is variable A equal to some value OR variable B equal to some other value?").
Continuous integration: A development technique where code is continually added into a central version of a product in small development cycles, usually when it can show it matches Unit Tests in a process of test-driven development.
Constant: A variable whose value either cannot change, or is not intended to be changed. Some languages provide special provision for restricting change in some variables. Constants are usually denoted with a special name formats, such as SCREAMING_SNAKE_CASE.
Control Flow: The order in which a program executes. A program will usually have a starting point (for example, the top of a specific file), but the path of the execution can skip around any give file, or between files, depending on control flow structures, usually keywords. Standard control flow includes branching based on a condition; looping through several values or until some condition is satisfied; procedures which are called and return some value and which may or may not be in some other object.
Debugging: The process of finding and fixing issues with code, otherwise known as bugs. This may be done by looking through the code manually; printing out key messages as the software runs; getting a computer to identify the issues when they stop something happening; or running through the code a line at a time to see where it is failing with a "debugger".
Declaration: The announcement in code that a variable, procedure, or class exists. In some languages (e.g. Python) the first assignment of a variable is taken implicitly as the declaration; in others there is syntax allocated specifically to doing this (for example in manifest typing).
Declarative programming: A programming paradigm in which the programmer says what the result of a program should look like, and works backwards from this (in contrast with imperative programming in which a result is stepped towards.
Decorator: A design pattern in which functionality is wrapped around pre-existing code (for example a class) with other code. However, in Python, also a specific form of this, where code or processing can be injected into code using the "@" symbol: a type of syntactic sugar to make such code clearer and hide complicated framework or toolkit code.
Delimiter: A delimiter is a character or a sequence of characters used to specify the boundary between two seperate pieces of plain text or other data streams. For example, a comma will seperate pieces of information in a Comma-Separated Values (CSV) file.
Deprecation: Discouraging the use of some piece of code, often a procedure identified in an API. This is usually because a more efficient solution (or one that fits better with the code philosophy) exists, though rarely it may be a warning that the code will not be supported, or will be removed in the future.
Deserialisation: Deserialisation is the process of converting a series of bytes into an usable object or data structure. The opposite process is known as serialisation.
Design by contract: A component of some development processes whereby the interfaces that code will use to communicate are designed first. If code matches these interfaces and produces the expected results, it should work as a whole. Essentially related to test-driven development.

Development process

The project management structure centred on code development within which code is built.

Domain Name / Domain Name Service (DNS)

A domain name is a human memorable address for a machine on the global network. It is an alias for an IP address, the lookup being completed by a call (or "DNS lookup") to the Domain Name Service, a distributed list of names and addresses scattered across the network.

Duck typing

The idea that in code, any object can be used in a situation as long as it has the variables and procedures inside it to match the use it will be submitted to. For arguments to procedures, this is formally a type of "polymorphic parameterisation" and works well with an inheritance hierarchy. A part of parametric polymorphism.

Dunder

An alias for the double underscore "__" notation. Coined by Mark Jackson, 2008.

Document Object Model (DOM)

A broad API or view of a page of nested markup that treats the page like a tree structure for the purposes of navigation.

Dunder

An operator (".") usually used to find elements inside an object, class, or library.

Dynamic languages

Dynamic programming languages are high level languages which are able to execute many common programming behaviours at runtime rather than deciding what to do at compile time. Alternatively, static programming languages need to be compiled into machine code before runtime.

Encapsulation

One of the main tenets of Object Oriented Programming; that data and the procedures to act on it should be within the same object/class, and that direct access to the internal workings of that object/class should be restricted, access instead being through the API.

Encoding

Encoding is the process of converting information, characters for example, into another form or representation using a set of specific rules. Most often used to describe the representation of human language characters as binary allowing characters to be stored and displayed. Generally, for example, the foundations of character encoding lie in ASCII, which represented 128 different characters as seven bit binary numbers. The letter 'A' for example was represented by the code: 1000001.

Escape characters

Escape characters are a way of writing characters that are either hard to display on a keyboard, or have additional meanings in a language and therefore are hard to put into a literal. Generally these are represented using a backslash, for example "\n" represents the invisible "newline" character which is found at the end of a line of text and causes text to drop a line, and, because of its use in escape characters "\\" represents "\". However, alternative schemes exist, in, for example HTML.

Evaluation

The determination of the result of an expression.

Event based programming

An asynchronous programming structure where the code waits for signals from a graphical user interface before running the appropriate code "registered" (or "bound") to the GUI element.

Exception handling

The capture of an issue raised by whatever is running a program; usually associated with encapsulating the issue as an object and allowing the coder to deal with it before the issue breaks the program. In some languages (e.g. Java), coders are forced to pre-emptively deal with issues if they might arise; in others, exception catching is optional.

Execute / Run

Starting a computer working through the process of acting on code to achieve its associated task / execution of the code. The period when this is happening is known as "runtime".

Expression

A chunk of code that evaluates to some value (e.g. 2 + 2). Expressions may or may not have side effects.

Extension (or Embedded) scripting

Script production to control an application while embedded inside it. Some applications (e.g. ArcGIS; Microsoft Office) provide an environment in which scripts can run; an API for controlling the application; and an application object to use to talk to the application.

First generation language

The earliest kind of computing language, initially programmed by adjusting hardware like switches. The code was represented as binary code statements, each of which would cause a cascade of changes through a computer as electrical pulses adjusted the hardware. Manipulating the cascades allowed the completion of mathematical and hardware tasks that built into a solution to a problem or an adjustment of the machine. Such languages are still at the core of computers in the machine code, but are rarely used directly by programmers.

A language where abstraction is at such a level that the programmer doesn't even consider tasks that need to be undertaken to fulfil a solution (c.f. Fourth Generation Languages), but concentrates of defining what would qualify as a solution and leaving it to the computer to solve it.

Firewall

Software that controls communications into and out of a computer, with the aim of preventing security issues. A firewall might, for example, close unnecessary ports or limit incoming messages to only responses replying to messages initialised on the machine.

Flushing

Flushing is the forcible writing of data out of a stream. Occasionally data can be stored in a buffer longer than you might like (for example if another program is reading data as you're writing it, data might get missed is it stays a while in memory), flush forces data writing.

Fourth generation language

A language that has such a high level of abstraction that the programmer does not need to know anything about the underlying computation or hardware, but concentrates on defining a sequence of tasks that need completing, for example by dragging and dropping them into a timeline.

Free variable

A variable in Python which can be used in a block, but which isn't declared within it, or limited to its scope, while not being global. One needs to be aware that often while it is ok to use a free variable in Python, assignment in a block can cause the variable to become a new local variable both back and forth throughout a block.

Function

In general a synonym for a procedure, though some languages utilise apparent synonyms for slightly different things, so, for example, Python distinguishes between a function (procedure) and method (procedure in an object), and VBA distinguishes between a subroutine (a piece of code called without returning a value) and a function (a call built into an expression and returning a value &ndash though there are also more subtle differences).

Functional programming

A branch of declarative programing in which the solution desired from the program is expressed, and then as nested sequence of function calls put together to generate the desired result. In general, this aims to reduce the number of stateful variables, preventing side effects. Functional languages were less popular than Imperative languages because they are less intuitive to write, but have risen in popularity because the reduction of side effects allows programs to be more easily split between processors on modern multi-processor machines.

Garbage collection

Garbage collection is a form of automatic memory management. Objects which are no longer in use by a programme are removed from memory. This is usually determined by seeing when the program no longer holds references to the object, and when, therefore, it can no longer be identified for use within the code.

Global/Module variable

A global variable can be seen anywhere within a program or runtime environment. A module variable is similar, but the scope is limited to, or through, a module.

Glue scripting

Script production to pull together several other pieces of software and code to achieve some goal, for example an analysis.

Graphical User Interface (GUI)

The graphical interface through which users interact with software. On personal computers this is generally centred on the "WIMP" structure (Windows; Icons; Menus; Pointer). GUIs generally contrast with Command-line interfaces.

High level language

A language with a high (or 'strong') level of abstraction, that is, its representation disguises the complications of the underlying machine code that controls the hardware closely.

HyperText Markup Language (HTML)

A system for 'marking up' (structuring and enabling) the hypertext pages of the World Wide Web.

HyperText Transfer Protocol (HTTP)

A protocol for the gaining and sending of hypertext over the internet, almost exclusively used for web communication.

Hypertext

A text or text system in which terms are linked to additional information. Although hypertexts have a long history include such things as encyclopedias, the best known example is now the World Wide Web.

Identifier

An identifier is a lexical token (i.e. a label) for an entity such as a variable or procedure.

Indentation

Although indentation is not a requirement of most programming languages' syntax, it is good practice to distinguish nesting in code by indenting it. In some languages, most notably Python, it is demanded in the syntax as distinguishing between blocks of code and to clarify the link between control flow constructs. An indent refers to the white space to the left of the first element in a line of source code. A "dedent" is the opposite. For most languages the assumption is that TABs will be used for indenting, though Python standards suggest four spaces.

Instance

An object of some specific class is regarded as an "instance" of that class, created by a process of "instantiation".

Instance variable

A variable inside an object, created with the object, and existing all the time the object exists, as distinct from variables associated only with procedures or (more rarely) a class. In general such variables are declared inside a class but outside procedures. They may be destinguished from class variables by whether they are called from objects, or have special handling (for example Python's self.variable_name setup).

Imperative programming

A programming paradigm in which a series of statements are run sequentially to adjust the computers state, usually held between statements by variables. A series of statements build up to create the programmatic result (in contrast to declarative programming).

Import

The process of linking a library to code in Java and Python. In Python, the period during which this occurs is known as "import time".

Instructions

Informally a request for the computer to do anything, but more formally a single command in machine code. A computer's "instruction set" is the set of commands that can be issued to change the hardware state.

Interface

In object oriented programming, interface has two meanings: the first is the public procedures for interacting with a object (see API), the second is a description of the former which a class can claim to implement (for example, through an inheritance system; albeit one where no concrete code is inherited). Interfaces of this second type allows classes to promise they will match certain structures or APIs. These are sometimes called Abstract Base Classes or Abstract classes (though these can have slighly different meanings), and are, generically, essentially a form of communication protocol. Interfaces more generally are the code and software utilised to communicate with a computer or program, e.g. a Graphical User Interface.

Internet

The global network of computers. Although connections are enacted utilising a number of protocols, it is often regarded as those elements specifically utilising the TCP/IP protocols.

Interpreter

Directly runs human readable source code once (rather than producing code that cannot be read by a human that can be run multiple times like a compiler). In practice, the interpreter may produce one-use bytecode (a stage which might be called compilation) and ask a virtual machine/runtime environment to actually run the code (which might be called interpretation).

Integrated Development Environment (IDE)

A text editor with extra functionality to help with writing code. Generally include one or more of: syntax colouring; line numbering; push button running; error identification and help; autocomplete of keywords and procedure names; GUI building help.

Inheritance

One of the main tenets of Object Oriented Programming. In an object oriented system, when a class inherits from another class, it invisibly picks up code from within the other class, without having to explicitly implement it itself. The class inheriting code is known as the subclass, while the one it inherits is known as the superclass. In general, objects are built up in an inheritance hierarchy of increased complication with superclasses representing the more generic behaviours and properties. Inheritance plays well with duck typing, where subclasses can be treated like superclasses in code that only uses superclass APIs.

Implicit typing

Broadly, the opposite of manifest typing in which data types are associated with values rather than variable labels. As values can't usually be predicted prior to the program running, this is usually associated with dynamic languages.

Instance variable

A variable whose scope is an object, and with which each object has its own copy. There is often some cross-over in the declaration of these and class variables, though access to them is through objects.

IP address

A numerical address for a machine on the global network, working as part of the TCP/IP. It is common for such addresses to be also allocated a human-memorable name, the lookup being completed by a call to the Domain Name Service.

Iterator

A design pattern and associated implementations in which ordered data is held in an object which, when requested gives the coder the data one element at a time.

Keywords

Words used in a programming language for a special purpose, and not available for other uses such as variable names.

Keyword arguments

Parameters attributed values based on the name with which arguments are passed into a procedure. Known as "kwargs" in Python.

Lambda function

While the term "lamdba functions" has a wide range of related uses, what it usually means in coding is a short procedure with no name that can be embedded within code. Such functions are often self contained, with the scope of internally declared variables being limited to the lambda. This limits side effects, and can make lambda functions popular for concurrent programming.

Legacy code

Code that is, in some sense, unsupported or otherwise out of date. Usually this is code in an older language which is still used either because there isn't the will, knowledge, money, or time to replace it. Legacy code can be very stable where hardware is reliable and sofware isolated from the internet, but it is liable to sudden, confusing, and expensive failure where these are not true.

Literal

A literal is a notation for representing a fixed value in source code. Literals are often used to initialise values. "Hello" could be a string/text literal, for example.

Libraries

A library is a collection of resources made available for other coders to use. Libraries can be loaded into a program as it is compiled, or later as the code is running/starting (a "dynamically linked library" or DLL). Libraries are often synonymously associated with "class libraries" (collections of classes used in object oriented programming) and "packages" (a bundled set of code with a specific namespace). Libraries may be a collection of files, a collection of files in an encapulating file format (e.g. a zip file), or a single file (for example, many Javascript libraries, or Python modules).

Literate programming

A form of programming in which human language is the chief component describing the logic in documentation, and the code itself is there as a backgrounded element. This is heavily documentation-led programming, in broad, but not exact, contrast to Self-documenting code.

Local variable

A variable whose scope is limited to a sub-element of a class or program, for example, a procedure.

Low level language

A lanaguage with a low level of abstraction, that is, its representation maps onto the underlying machine code that controls the hardware closely.

Machine code

The instructions, directly (more or less) controlling the hardware of a computer. At the lowest level 'numerical' machine code is written in written in binary. The level to which a language hides the complications of the machine code is the abstraction.

Manifest typing

Manifest typing is the process of explicitly identifying a variable's type when it is first used or declared. Manifest typing is usually associated with static programming languages as the object type of the variable is assigned at compile time. Alternatively, languages which use 'Implicit Typing', deduce a variable's type at runtime and do not require explicit identification of a variable's type upon declaration.

Markup

A language which imposes a structure and/or semantics on plain text. Probably the most common markup language is html.

Marshalling

Marshalling is the process of converting objects or data structures into a format (usually a series of bytes) so the can be stored or transmitted. Storage maybe in a file or in memory buffer. This process is sometimes known as serialisation. The opposite process is known as deserialisation or demarshalling.

Memory (Computer memory)

The computer hardware devices involved in storing information for immediate use in a computer. Usually divided on most machines into Read Only Memory (ROM) (largely used for starting the system); Random Access Memory (RAM) (used for quick storage associated with running programs); and Hard Drive Memory (long-term data and software storage). Excess use of RAM can lead to the use of "Virtual Memory" stored on the harddrive, and dramatically slow programs.

Method chaining

A construction usable where procedures returning objects containing other procedures can be chained together rather than attaching each procedure call result to a separate variable, thus:
a = b.c().d().e()

Module / Package

A collection of code that can be called upon to do specific jobs. This can include libraries of classes for use in code. In Java and Python, packages have a namespace, whereas in Python a module doesn't. Packages in some languages can be associated with a package manager for installing the packages and ensuring new code recognises the location of the packages on a system.

Mutator method

A procedure for setting the value of a variable inside an object. Often called a "setter", as generally such procedures are named "set" and then the variable name. Often associated with direct access to the object being limited through access control.

N-tier architecture

A common architecture for enterprise (business) systems, especially on networks such as the internet. This architecture involves splitting core functionalities likely to take significant processing across different machines, each running a separate piece of software that acts as both a client and server in communicating with other machines to do a job. And example of a 3-tier system is a database holding data, working with "middleware" which does data processing, and a client that does visualisation.

Name mangling

The automated alteration of variable or procedure names for some purpose during the preparation of code for running; often so that elements with the same name don't clash (as a replacement for, or supplement to, a namespace).

Namespace

A name or series of names used to identify code and other resources from each other. Examples include a file directory tree, but often namespaces attempt to name code uniquely, for example through a combination of unique internet addresses and file locations. Unique namespaces allow a programmer to talk about code in a unique manner. For example, there might be any number of code files called "mycode.txt". If we want to use a specific "mycode.txt" in our program, how do we talk about it? Adding an internet address owned by the developer of mycode.txt to the name makes that version unique.

Native code

Generally code compiled to machine code for a particular system. Interpreted code can sometimes link with, and make use of, native code, and some virtual machines will make use of pre-existing and highly optimised native code to run popular or intense source code instructions rather than compiling everything anew.

Null object

A null object is a behaviourless object often attached to a variable to show it isn't attached to anything useful or hasn't been initialised. It can be used, for example, to remove a variable label from its current value but leaving the variable label in existence. Different languages have different names for this: Python uses 'None'; Java has 'null'; and VBA has several different null objects (Null; Nothing; Empty) with slightly different meanings.

Object

A collection of code accessed via a variable label and defined by a class which acts as the type of the variable/object. Multiple objects can be instantiated from a single class, essentially copying the class code. Usually classes/objects try to represent objects in the real world or collections of procedures to deal with specific data. Variables and procedures with the object can be accessed via the dot operator.

Object Oriented Programming (OOP)

A programming paradigm in which code doing a specific set of jobs, usually on a particular kind of data, is separated off into "objects" that encapsulate those jobs (and data) and make them available for other code to use. Essentially this is an extension of procedural programming, but the procedures are in source code files external to the main body of the code that initially starts running. In addition, there are generic descriptions of such objects ("classes") which can also inherit procedures from other classes. One big advantage of OOP is that code is usually made up of a small percentage of new code, and a very large percentage of code written by others and made available to do complicated jobs (for example, displaying text on a screen).

Ontology

Ontology is a structured knowledge framework, for example, formal naming and definition of the types, properties and relationships that exist for entities. It usually details the associatated objects' semantics.

Open Source Software

Open source software is software for which the source code is publicly available, and may be adjusted and distributed under the limitations of an Open Source License. Licenses are ratified by the Open Source Initiative.

Operating System

Software managing the interaction with file systems and other hardward, therefore controling the running of other software. Classic OS include Windows and various systems matching the POSIX specification.

Operators

Symbols in a computing language that act on surrounding code or values. Operators may be uniary (work on one thing) or binary (work on two things) or more. They may be prefix (before the thing operated on), infix (between two) or postfix (after the thing). Example operators working on values include the infix binary "+", which usually adds two numbers. Example operators working on code include the infix binary "." which finds code inside an object. Operators generally have precedence.

Ordered data

Ordered data has a sequence in which one data point is ahead of another in a store based on some key piece of information. This doesn't, however, mean than this matches a natural order and the data is sorted as we would intuitively think of it; order, may, for example, be on the basis of when elements where added to the store.

Ousterhout's Dichotomy

John Ousterhout's division of high level languages into systems (or application) languages (with high flexibility/power, high speed, and a complicated learning curve) and scripting languages (with low power, low speed, but an easy learning curve). As Ousterhout has pointed out, better scripting language design, faster computer speeds, and a greater flexibility in the computing elements pulled into languages is resulting in something of a convergence and/or equalisation.

Overloading

In an class, the notion that you can have multiple versions of the same procedure and the system will utilise the one that matches up with the parameters sent. Some languages allow this, while others, like Python, do not (or, at least, not easily). Part of "ad hoc polymorphism".

Overriding

In an object inheritance hierarchy, the notion that a subclass can provide a procedure or variable with the same declaration as one that would be inherited from the superclass, and that this new subclass element has precidence over the superclass one.

Package / Module

Parameters

Variables within code which don't initially have values, but which can be set up to make the code run in different ways. Parameterization allows the building of flexible code that can be run for different purposes or in a different manner. Often set up using arguments. See keyword arguments and positional parameters.

Parentheses

() Sometimes known as curved brackets. Often used to denote the arguments of a function.

Parallel programming

The separation of code execution into similar parts running symultaneously and occasionally communicating to unify on a job; for example the breaking up of an image for image processing on different machines. Contrast with the similar concurrent programming where generally a program is broken into dissimilar parts to run on a single multi-core chip machine.

Pascal case

Pascal case is the practice of writing compound words or phrases by capitalising every work in a sequence, removing the spaces, e.g. PascalCase. The difference (a first capital) is enough to mark it out from the more common camelCase. Alternatives include camelCase, SCREAMING_SNAKE_CASE, and snake_case. See case styles.

Pass by assignment/sharing

When a procedure recieves data that isn't a copy of an argument passed in, but rather a reference to the value/object associated with it in memory. This means it can adjust the value and the value will change outside the procedure. Contrasted with pass by value and pass by reference, the latter being different in that in pass by assignment one can't adjust what the external argument variable is refering to.

Pass by reference

When a procedure recieves data that isn't a copy of an argument passed in, but rather a reference to the variable associated with it in memory. This means it can adjust the variable and the variable will change outside the procedure. Contrasted with pass by value and pass by assignment/sharing, the latter being different in that in pass by assignment one can't adjust what the external argument variable is refering to.

Pass by value

When a procedure recieves data as an argument, the data is copied and a whole new variable is created for the procedure. This usually means that changes to the value are limited to the procedure, and variables external to the procedure are unaffected. Contrasted with pass by reference and pass by assignment/sharing.

Patterns / Software design pattern

Patterns are community recognised descriptions of how to structure code to solve specific issues. They generally describe the overall structure and approach to code, and in this sense are distinguished from algorithms, which are generally series of suggested statements, though some patterns do reach this level of detail. c.f. antipatterns.

Polymorphism

One of the main tenets of Object Oriented Programming; that access to key procedures should be made as simple as possible by allowing flexibility in terms of the arguments passed in.

Positional parameters

Parameters attributed values based on the order in which arguments are passed into a procedure and the order in which parameters are listed to receive them.

POSIX

A set of standards for constructing operating systems, the most notable versions of which are the Linux family, MacOS, and UNIX.

Precedence

The language-dependent order in which operators (usually mathematical operators) are processes in an expression (usually a mathematical equation) for the sake of computational ease. In most languages, nesting parts of the expression in parentheses will override the operator sequence and improve human readability, so 2 * 3 + 2 is ambiguous depending on whether addition or multiplication is done first, whereas (2 * 3) + 2 is clear.

Primitives

Primitives are core data types built into the language with a definite space set aside for each type in memory. Increasingly languages are moving away from primitives to have all data stored in objects.

Procedures

A programming paradigm in which code that is frequently used is cut off as a separate "procedure" such that it can be "called", that is run, from another piece of code before the execution returns to the calling code. In most languages there is a way of passing information into the procedure to adjust its behaviour or results and for procedures to return some value to the code that called it. Depending on the language and use, procedures are also called methods, subroutines, routines, or functions. While these terms are often synonymous, they sometimes denote subtle differences in treatment.

Procedural programming

Programming using procedures rather than jumps to labelled point within the body of a program using control flow constructions like goto. This reduces spaghetti code

Port

A number which acts as a flag on incoming communications to a machine, flagging which software the message should be directed to. As only one piece of software can 'listen' to a port at a time, the port numbers up to 1024 are assigned to key software. Ports are a weak point, as any message going to an open port will be directed to any software listening to the port, and so firewalls frequently close ports and/or only allow software that begins communications to receive incoming messages.

Punctuation

Symbols used to structure code, and demanded by the syntax. We might distinguish between punctuation, which marks syntaxic position, and operators that act on surrounding code.

Pseudocode

Not code that runs, but rather informal indicative code-like text that conveys the idea of code that might be developed by replacing the pseudocode with real code.

Reference

A mechanism for allowing code to access data stored in memory; typically a variable would reference some value or object. More than one variable label may reference the same data/code. When data/code in memory has no references, it can no longer be spoken of in high level languages, and is usually garbage collected.

Run / Execute

Starting a computer working through the process of acting on code to achieve its associated task / execution of the code; the time this occurs in is known as runtime.

Runtime Environment

See Virtual Machine / Runtime Environment.

Screaming snake case / All caps

All caps is the format of writing everything in capitals, e.g. ALL CAPS. Screaming snake case is a commonly used format for variables (mainly 'constants' that you don't expect to change) where all caps are linked with underscores, e.g. SCREAMING_SNAKE_CASE. It is named after the more common snake_case. Alternatives include camelCase, snake_case, and PascalCase. See case styles.

Scope

The areas where a variable exists and can be utilised within code (see blocks). In modern languages, different variables can usually have the same name as long as they have different scope. Generally, variables have scope (or are "bound") where they are declared.

Scripts

A short program designed to achieve a specific job, rather than provide a more flexible service to either users (as with applications) or software (as with systems). Generally (but not always) written in a scripting lanaguage. Amongst other classifications, scripts include code to pull other software together to achieve jobs (glue scripting), control or manage systems (control scripting), and control or manage software applications from a position embedded inside them (extension scripting).

Scripting languages

In Ousterhout's dichotomy, a language used for programming scripts, as opposed to a systems (or application) language. Amongst other classifications, scripts include code to pull other software together to achieve jobs (glue scripting), control or manage systems (control scripting), and control or manage software applications from a position embedded inside them (extension scripting). Some languages are specific to one of these remits but others cross several.

Second generation language

The earliest kind of easily human-readable coding language, using short codes to represent collections of underlying hardware operations. Still relatively low level i.e. with low levels of abstraction. .

Self-documenting code

A form of programming in which code is written in a way that reduces the need for comments, for example by having clear variable names and a structure which encourages code readability. This is comment-light programming, in broad, but not exact, contrast to Literate Programming.

Semantics

"Semantics" has a wide variety of meanings in computing, but in analysis is usually used to describe the meaning or context of data, that is, how it represents objects in the real world. Semantic information is often captured or associated with an ontology.

Serialisation

Serialisation is the process of converting objects or data structures into a format (usually a series of bytes) so the can be stored or transmitted. Storage maybe in a file or in memory buffer. This process is sometimes known as marshalling. The opposite process is known as deserialisation.

Side effects

A procedure or expression which affects code elsewhere, usually by changing a variable. Although use varies, expressions assigned to a variable, or procedures returning a value to be attached to a variable are not generally regarded in that respect as having a side effect.

Snake case

Snake case is the practice of writing compound words or phrases by replacing intervening spaces with a single underscore, e.g. snake_case Alternatives include camelCase, SCREAMING_SNAKE_CASE, and PascalCase. See case styles.

Socket

A software representation of a connection to a computer over the internet. Often used with a stream to send data between machines.

Sorted data

Sorted data is ordered on some key piece of information. Informally, we usually think of sorted data as matching a natural or human-defined order: for example numerical order or by alphabetical position.

Source code

Human readable text containing instructions for a computer, that is ultimately converted to something a computer can read

Spaghetti code

Code that is hard to follow because of an over-complicated control flow.

State / Stateful

State is the configuration of a computer, as stored in memory. A computer is stateful if it can have state. Usually when people use "state", they mean Program State, that is, the state determined by a specific program and associated with variables (i.e. not including any state formed by the code itself running other than values placed in memory).

Statements

A statement is the smallest unit of programming that can be evaluated to completion and ask the computer to do a task. Usually this corresponds to a line of code.

Static programming languages

Static programming languages are high level programming languages whose source code must be complied into machine code before the program can run. Static programme languages use Ahead-Of-Time (AOT) compiling to produce optimised code which saves disk space, memory and battery-life at runtime; they generally run more efficiently than dynamic languages.

Standard streams

stdin, stout and sterr are three standard streams associated with running programs, representing input, output, and error logging, respectively. For most programs, these are the keyboard, screen, and screen respectively. They can be redirected (for example to push a file into a program or write to a file), and the stout of one program can be connected to the stin of another using a "pipe" to chain the programs together.

Stream

A software connection down which data can flow; they can be imagined as a pipeline. Streams usually connect to resources outside a specific program, but can be used internally as well; for example to temporarily collect an arbitrary number of points of data, later converted to a more constrained object.

Subclass

In an inheritance hierarchy, the class doing the inheriting from a superclass. Sometimes called a "child class" or "derived class".

Superclass

In an inheritance hierarchy, the class from which the inheriting is done by a subclass. Sometimes called a "parent class" or "base class".

Syntactic sugar

Syntax that doesn't add new meaning to a language, but which makes complicated code simplier to express, or which hides it away. For example, in Python, the notion that procedure calls that look like: object.procedure() are actually usually running as Class.procedure(object).

Syntax

The structuring and sequence of terms that is necessary in any given location to get a program to work. In some respects the computational equivalent of grammar.

Systems

A piece of software providing services to other software. A common example is an operating system. c.f. applications.

Systems (or Application) programming languages

In Ousterhout's dichotomy, a language used for programming full systems or applications, as opposed to a scripting language.

TCP/IP

The combination of two protocols, the Transmission Control Protocol and the Internet Protocol, used for communication over the internet.

Test driven development

A development process centred on building Unit Tests early in the process and building code to satisfy the tests. See also design by contract.

Third generation language

Computing languages reading more like human languages and mathematic than something interpreted by a machine, hiding almost all of the actual action of the hardware (c.f. Second Generation Languages) and therefore classed as high level, that is, having high levels of abstraction.

Thread

A fraction of a program process separated off and running as a separate entity, communicating with the main program ("main thread") and other threads when needed. In theory, this could run on a different core chip in the computer, meaning it would run in synchronously (concurrently) with other threads, improving performance, but threads have other uses; for example, keeping track of multiple users.

Type

A definition of a specific form of data, usually in a variable; these can be simple types like "integer" or container types like "list", or complicated types of code with their own variables and procedures inside, i.e. classes.

Unified Modelling Language (UML)

A set of standards for drawing code, code flow, and uses, as diagrams.

Uniform Resource Locator (URL)

An addressing system that locates machines on a network, the files on a machine to access, and a method for getting them. Informally, this is now used so often for the web it is called a "web address". URLs are a more specific form of Uniform Resource Identifier (URI).

Unit test

Code to test that other code meets a set of requirements, usually centred on the API. Often associated with test-driven development.

Variables

A set of values or code held inside the computer with an attached label to refer to it. Variables are considered to hold the state of the computer with respect to the program running. Variables have scope. See local; free; class; instance; and local variables.

Version control

Version control systems keep track of changes to code, allowing developers to roll back changes.

Virtual Machine / Runtime Environment

Process Virtual Machines are programs that act as a platform in which to run other software. They may include an interpreter, and will usually add security to prevent code run within them from damaging the local Operating System. Runtime Environment is an older term for the specific element running the code. Process Virtual Machines are not to be confused with System Virtual Machines, which recreate a whole computer inside another, for example allowing you to run Linux inside Windows.

World Wide Web

The World Wide Web, or "the Web", is an internet-based system of hypertext resources and associated media.

Geography Programming Courses

Dictionary of terms used