Computer Science Paper 2 Definitions

Abstraction = Representing 'real world' problems in a computer using variables and symbols and removing unnecessary elements from the problem.

Algorithmic Thinking  = Identifying the steps involved in solving a problem.

Flowchart  = A diagram that shows the inputs, outputs and processes in an algorithm.

Pseudocode = A simplified programming code that is not language specific, used to design algorithms.

Linear Search = Each item in the list is checked in order.

Binary Search = An ordered list is divided in two with each comparison.

Bubble Sort  = Moves through a list repeatedly, swapping elements that are in the wrong order.

Merge Sort = A list is split into individual lists, these are then combined (2 lists at a time).

Insertion Sort = Each item is taken in turn, compared to the items in a sorted list and placed in the correct position.

Ordered List  = A list where elements are arranged in sequence.

Computational Thinking = The use of computers to solve problems by the development of algorithms.

Decompostion = The breaking down of large computational problems into smaller ones.

List = A linear set of data.

Unordered List = A list where elements are not arranged in any particular sequence.

Dry Run = Walking through an algorithm with sample data, running each step manually.

Trace Table = A table that follows the values of variables to check that an algorithm is functioning correctly.

Semantic or Logical Error = An error in the code that is  a mistake in the logic or steps of the algorithm.

Syntax Error = An error in the code where expected syntax is not present or used correctly.

Defensive Program Design = Developing programs that are robust and prevent deliberate or non-deliberate misuse.

Data Validation = A check made by program code to ensure that data entered is sensible or reasonable by applying certain rules to the input.

Format Check = Data Validation method that ensures the data entered is in the right format.

Length Check = Data Validation method that ensures the data entered isn't too short or too long.

Lookup Table Check = Data Validation method that ensures the data entered matches a value from a particular table.

Presence Check = Data Validation method that ensures that data entered has actually been entered.

Range Check = Data Validation method that ensures the data entered falls between a certain range of values.

Spell Check = Data Validation method that ensures the data entered matches words from a dictionary.

Input Sanitisation = A method for validating data that prevents misuse by ********* out certain unwanted characters or strings from input.

Authentication = A coding method to check that the user is who they claim to be. Can be via password or something physical like a thumbprint.

Maintainability = A robust program should be easily maintainable so that changes can be easily made to meet new requirements.

Runtime Error = An error that may cause program errors or even a crash even if there appears nothing wrong with the code. E.g. running out of memory.

Iterative Testing = Testing the code as it is designed either line by line or a section at a time.

Final or Terminal Testing = Testing that is carried out when the program has been written. If an end user is involved this is sometimes called Acceptance Testing.

Test Data = Selecting suitable values to test the program's functionality. Can be valid (in range), out of range, boundary, null or invalid data.

Test Plan = A formal document that sets out each test of the program's functionality with information about each test e.g. date, type, expected result.

Machine Code = First generation language directly executable by the processor, written in binary or hex.

Assembly Language = Second generation language that uses mnemonics to represent machine code instructions on a one-to-one basis.

Programming Language = Third generation language that uses English-like keywords where one instruction translates to many machine code instructions.

Declarative Language = Fourth generation language in which facts and rules are stated to describe what computation should be performed not how to do it.

Assembler = Translates Assembly Language Code into Machine Code.

Compiler = Translates entire source code of a Programming Language to Machine Code all at once. Usually provides some optimisation and error reports.

Interpreter = Translates entire source code of a Programming Language to Machine Code line by line. If an error is found, execution stops.

IDE = An Itegrated Development Environment provides an editor, error diagnostics, a run-time environment and a translator for writing code.

Bit = A binary digit. Can be 0 (false) or 1 (true).

Nibble = A group of 4 bits. Represents a single hexadecimal digit.

Byte = A group of 8 bits with 256 different possible combinations.

Kilobyte (KB) = 1,024 Bytes.

Megabyte (MB) = 1,024 Kilobytes.

Gigabyte GB) = 1,024 Megabytes.

Terabyte (TB) = 1,024 Gigabytes.

Petabyte (PB) = 1,024 Terabytes

Binary = A number system based on 1s and 0s. Used in computers because transistors can be in one of two states.

Hexadecimal = A number system based on 0 to F. Easier for humans to use and easy to convert to and from binary.

Binary Shift = A binary shift increases or decreases the number represented by (approximately) a factor of 2.

ASCII = American Standard Code of Information Interchange is a 7/8 bit system for representing characters.

Unicode = Unicode is a 16 bit system for representing characters.

Character Set = The set of possible characters that can be represented in a computer system.

Check Digit = A form of redundancy check used for error detection (Data Validation). E.g. ISBN 13 or EAN 13.

Vector Image = An image drawn by following a set of mathematical instructions. Scales without pixelation.

Bitmap Image = An image created by an invisible grid of pixels with each pixel being assigned a particular colour.

Metadata = Literally data about data. Can describe the structure of a data file and is usually found at the start.

Resolution = The number of pixels used to represent an image.

Colour Depth = The number of bits used to store the colour information for each pixel.

Direct Colour = When red, green, blue (and transparency) levels are mixed to create the desired colour.

Digital Audio = Encoding sounds by converting thousands of samples per second into binary data.

Codec = Coder-Decoder. Used to convert between analogue and digital sources.

Sample Frequency = The number of audio samples captured every second.

Sample Size (Bit Depth) =The number of bits available for each individual sample.

Bit Rate = The number of bits used per second of audio. Equal to FREQUENCY x BIT DEPTH x CHANNELS

Data Compression = The process of encoding data so that it needs fewer bits/bytes to represent it.

Lossless Compression = Compression of data files without losing any of the information. The process is completely reversible.

Lossy Compression = Compression of data files where some of the information is lost but the loss of accuracy is acceptable. Not reversible.

Logic Gates = Take binary input(s) and provide an output depending on their type.