Introduction to Coding Concepts

Absolute Value

• The number itself, ignoring whether it's positive or negative.

Abstraction

• Hides the details; limits control.
• Recipe title, omitting steps.
• Opposite of an algorithm.
• Used in coding with functions, variables, etc.

Algorithm

• Sequence of steps to solve a problem.
• Detailed instructions.
• Opposite of abstraction.
• Provides maximum control.

ASCII

• Common text encoding format.
• Basic text, without formatting.
• Used by computers and the internet.

Append

• To add something to the end of a data structure.

Application (App)

• A program.

Argument (or Parameter)

• Items passed to a function inside parentheses.
• Separated by commas in some languages.
• Example: math.sqrt(num).

Assembler

• Translates assembly language instructions into machine instructions.
• Human-readable instructions.

Assembly Language Instructions

• Instructions slightly easier for humans to understand than machine language.
• Translated to machine code using an assembler.

Assignment Statement

• Gives a value to a variable using an equals sign.
• Variable name on the left, value on the right.

Base

• Base 2 (binary): Numbers 0 and 1 weighted by increasing powers of 2.
• Base 10: Numbers 0-9 weighted by increasing powers of 10.

Basic Input/Output System (BIOS)

• First program to run on starting a computer.
• Sets up basic computer peripherals.

Binary Numbers

• Using only 0 and 1.
• A computer's basic storage unit.

Bits (or Binary Digits)

• Smallest unit of data in a computer.
• Two states: 0 or 1.

Bug (or Logic Error)

• Coding error with flawed logic.
• Code doesn't perform as expected.

Byte

• A sequence of 8 bits.

Cache

• Small, fast RAM on a processor chip for faster access.

Camel Case

• Naming convention; start each word after the first with a capital letter.
• Example: camelCase.

Case Sensitive

• Uppercase and lowercase letters are treated differently.

Central Processing Unit (CPU)

• See processor.

Circuits

• Connections of switches.

Clock

• Measures the speed of a processor's instructions.
• Ticks at a specific frequency (e.g., MHz, GHz).

Code

• Written representation of a program (using human-readable text)

Code Point

• Unique number representing a character using Unicode.

Compilers

• Programs automatically translate high-level code into machine instructions.
• Creates executable programs.

Computational Thinking

• Breaking down problems into smaller, logical pieces.
• Looking for patterns in data and using them to create solutions,
• Useful for big problems.

Computer

• A device that interacts with a processor using memory.
• Includes personal computers, laptops, tablets, and more devices.

Concatenate

• Joining two or more strings together.

Container

• Data structure for holding related values.
• Example: list, tuple, string, set, dictionary.

Core

• A processor contained within an IC.

Crash

• Program closes unexpectedly (typically due to error).

Data Type (or Type)

• Defines how data behaves.
• Categorization of information (e.g., name, date).

Debugging

• Process of finding and fixing program errors.
• Troubleshooting a program.

Decrementing

• Decreasing a variable by a certain amount repeatedly.
• Opposite of incrementing.

Disk (or Hard Drive)

• A storage device (non-volatile).
• Stores data like files, etc.

Element

• An item in a list or other sequence type.

End-of-Life

• Point when a product no longer receives improvements, support, or fixes.

Error

• Problems in a program.
• Includes logic errors, syntax errors and runtime errors.

Escape Sequence

• Two-part sequence within a program that tells the program to display, show, do something other than what it literally means.
• Example: \n for a newline.

Evaluate

• Doing the math or calculation in an expression.
• A computation of results.

Executable (or Executable Program)

• A program already formatted for direct execution on a machine.
• A sequence of machine instructions.

Expression

• Code that returns a value after evaluating.

Execute

• Run a program or code.

Floating-Point (or Float)

• Data type for real numbers (including decimals).

Format Specification

• Rules to format a piece of data.

Formatted String Literal (f-string)

• Using formatting placeholders inside strings.

Function

• A set of statements that can be reused by referring to the function.
• Can receive input via arguments (in parentheses after the function's name).

Garbage Collection

• Automatically freed-up memory space (in some languages).

Gigabyte

• A billion bytes.

Good (or Best) Practices

• Coding conventions to improve readability, maintainability, and reduce future problems.
• Example: proper naming conventions and comments.

Hardware

• Physical parts and components of a computer.

High-Level Languages

• Languages like Python where the instructions are more closely related to human language, as compared to machine language.

Identifier (or Name)

• Label or name for something in a program.
• Cannot be used for anything else in the program (e.g., reserved words).

Identity

• Unique numerical identifier that's assigned to each object.
• Shows the object's memory location.

Immutable

• Data value Cannot be changed after created. Integer, string.

Increment

• Increasing a variable repeatedly by a certain amount.

Incremental Development

• Developing a program in small, manageable steps, testing them.

Index

• An element's place in a sequence type (often starting at 0).

Input

• Data entered into a program (e.g., using keyboard, file).

Integer

• Data type for whole numbers (no decimals).

Interpreter

• Program that executes scripts directly.

Irrational Numbers

• Numbers that cannot be represented as a ratio of two integers.

Iteration

• Repeating a block of code multiple times, especially in loops.

Keyboard

• Peripheral that allows the user to input.

Keywords (or Reserved Words)

• Words that are already used by the language and cannot be used for variable or other names.

Leading Zeros

• Zeros before a number (e.g., 01, not 1).

Line

• Row or line of program code.

List

• Structure to hold sequence of objects.

Literal

• Data written directly in a program, like 3.1415 or "hello".

Logic Error

• An error in program logic causing unexpected results (a "bug").

Machine Instruction

• Lowest level instruction a computer understands.
• Usually binary (0 and 1).

Megabyte

• A million bytes.

Memory

• Computer's component for storing instructions and data.

Method

• Function associated with an object.

Microprocessor

• Central processing unit (CPU) on a single chip.

Module

• A file containing Python code.

Mutable

• Data values or contents of an object can be changed.

Name (or Identifier)

• A label or name for something in a program.

Name Binding

• Associating names (like variables) with objects in a program's runtime.

Naming Convention

• Set of rules for naming variables and functions.

Nesting

• Placing one block of code inside another block.

Non-Volatile

• Data that remains stored when power is off.

Numeric Type

• Data type including integers, floating-point numbers.

Object

• Instance of a class in an object-oriented language.
• Contains data (value)and type.

Operand

• Values used in calculation in a program.
• Example: 3 and 5 in 3 + 5.

Operator

• Symbols that perform calculations (e.g., +, -, *, /).

Operating System (OS)

• Program controlling and managing hardware.

Operator

• Symbol that performs a calculation.

OverflowError

• Occurs when a value is too large to be stored.

Output

• Information a program gives to a user.

Operand

• Values used in mathematical or logical operations.

OverflowError

• Occurs when an operation in a program creates a value that's too large for a computer to record (in the provided memory).

Peripherals

• Device that receives input.
• Devices that provide output from a computer.

Precedence Rules

• Order of operations in a calculation.
• Order in which operations are performed in an expression.

Processor

• Hardware that executes instructions.
• Central processing unit.

Program

• Sequence of instructions formatted for execution.

Programming Language

• Language in which programs are written.

Pseudocode

• Step-by-step description of code logic in human-readable language.

Pseudo-Random

• A sequence of numbers that appears random, but is generated according to a formula (so it is predictable).

Random Module

• Python module for generating pseudo-random numbers.

Reciprocal

• The inverse of a given number; divide by 1.

Refactoring

• Improving code without changing its functionality.
• Changing the code's internal structure.

Repeating Decimal

• A decimal number with an infinitely repeating pattern.

Replacement Field

• Placeholder in strings, to be replaced by a value in a formatted string, such as an f-string.

Respectively

• In the same order as previously mentioned.

Runtime Error

• Programming error not caught at compile time but during runtime or execution.

Scientific Notation

• Writing very large or small numbers (with scientific notation or exponential notation).

Script

• A sequence of instructions (program) that are executed by an interpreter.

Scripting Language

• Language often used for smaller tasks requiring simpler programs.

Screen (or Monitor)

• Output device that displays images to a user.

Seed

• Value (often a number) used by some algorithms to generate a sequence of numbers, typically to make the results repeatable.

Sequence Type

• A set of items arranged in a specific order.
• Elements can be accessed using an index (e.g., a string, list, or tuple).

Set

• Unordered collection of unique elements.

Software

• The programs that run on a computer's hardware (opposite of hardware).
• Example: Operating System.

Statement

• Line of code that tells the computer to do something.

String (or String Literal)

• Sequence of characters.
• Data type for text.

String Concatenation

• Combining strings together.

String Literal

• Literal values inside a string.

Storage

• Hardware or software mechanism for storing data.

Switch

• Component that turns something "on" and "off", either electronically or physically, controlling a circuit.

Explore fundamental coding concepts such as absolute value, algorithms, and ASCII. This quiz covers key definitions and functions that form the basis of programming languages. Test your knowledge on abstraction, arguments, and more.