Programming Basics

Learning Objectives

  • Understand the fundamental definition and purpose of programming.
  • Distinguish between compilation, interpretation, and hybrid code execution.
  • Explain how data (integers, negative numbers, text, and fractions) is represented in computers using binary.
  • Differentiate between syntax and semantics in programming languages.
  • Define variables, their scope, and standard data types.
  • Evaluate expressions using arithmetic, comparison, logical, assignment, and bitwise operators.
  • Describe basic input and output operations.

A comprehensive guide to programming fundamentals, compilation vs. interpretation, data representation, syntax, variables, data types, operators, and input/output operations.

Programming

Programming is the process of writing instructions (code) for a computer to execute. The goal is to solve a problem, perform a task, or automate a process.

1. How Code Runs: Compilation vs. Interpretation

Computers only understand machine code (binary). Therefore, the high-level code we write (like C++, Python, or Java) must be translated before the CPU can execute it.

Compiler

A compiler translates source code into another representation before execution. The target may be native machine code or an intermediate representation; a language implementation can use multiple compilation stages.

Interpreter

An interpreter executes a program by carrying out operations from its source or an intermediate representation at run time. It need not process source text one line at a time, and a runtime may also compile selected code.

Translation Methods

  • Ahead-of-time native compilation (common in C and C++): A compiler translates source files into object code and links them into a platform-specific executable before the program runs. Other compilation models may target an intermediate representation or use runtime compilation.

  • Interpretation: A runtime executes operations from source code or a translated representation. Python and JavaScript implementations may compile to bytecode or use just-in-time compilation, so “line by line” is only a rough introductory metaphor.

  • Hybrid (e.g., Java, C#): The source code is compiled into an intermediate bytecode, which is then interpreted or Just-In-Time (JIT) compiled by a Virtual Machine (like the JVM) at runtime. This provides a balance of speed and platform independence.

Common program translation models

These are common implementation patterns, not fixed properties of every language. Some runtimes compile source to intermediate code, interpret it initially, and compile frequently used portions to native instructions while the program runs.

Three labeled lanes compare ahead-of-time compilation to a target, interpretation of a program representation, and a hybrid virtual-machine model using intermediate code with an interpreter or just-in-time compiler.

Interact with the simulation below to understand how assigning a value to a variable allocates space in memory.

Variable Assignment

Memory Allocation

Code
let myScore = 10;
→
Memory Address: 0x00A1
10
Variable Name: "myScore"
When you assign a value to a variable, the computer allocates a space in memory to store that value and associates it with the variable's name.

2. Data Representation in Computers

At the lowest level, all data is stored as binary (0s and 1s). How do computers represent negative numbers, text, or fractions?

2.1 Representing Integers and Negative Numbers

A single binary digit is a bit (0 or 1). Eight bits make a byte.

Integer Representation

  • Unsigned Integers: Represent nonnegative values. An 8-bit unsigned integer can represent values from 0 to 255.

  • Signed Integers (Two's Complement): The most common method for representing negative numbers. The Most Significant Bit (MSB) acts as a sign bit (0 for positive, 1 for negative). To get the Two's Complement of a number: invert all the bits (1s complement) and add 1.

Forming negative five in eight-bit two’s complement

For this fixed-width example, +5 is 00000101. Bitwise inversion gives 11111010; adding one gives 11111011, the 8-bit two’s-complement encoding of −5.

The figure starts with positive five as 00000101, inverts its bits to 11111010, and adds one to obtain 11111011, which represents negative five in eight-bit two’s complement.

Integer Overflow

When an arithmetic operation attempts to create a numeric value that is outside of the range that can be represented with a given number of digits, an Integer Overflow occurs. This can lead to unexpected behaviors, such as a positive number wrapping around to a negative number in Two's Complement representation.

2.2 Representing Text

Computers use encoding standards to map binary numbers to human-readable characters.

Character Encoding

  • ASCII (American Standard Code for Information Interchange): Uses 7 bits to represent 128 characters (English alphabet, numbers, and basic symbols). For example, the letter 'A' is represented by decimal 65 (binary 01000001).

  • Unicode and UTF-8: Unicode assigns code points to abstract characters. UTF-8 encodes each code point using one to four bytes, preserving ASCII byte values while representing the wider Unicode range.

A character, Unicode code point, and UTF-8 byte

U+0041 identifies Latin capital letter A. UTF-8 encodes this ASCII-range code point as one byte, hexadecimal 41. UTF-8 uses multiple bytes for many other code points; this example does not imply every character has one byte.

Latin capital letter A is labeled U+0041 and encoded in UTF-8 as hexadecimal byte 41, equivalent to decimal 65 and binary 01000001.

2.3 Representing Fractional Numbers (IEEE 754)

Decimals (floating-point numbers) are complicated to store in binary. The IEEE 754 Standard breaks a floating-point number into three parts to store it efficiently, similar to scientific notation.

IEEE 754 Components

  • Sign Bit (1 bit): Determines if the number is positive (0) or negative (1).

  • Exponent (e.g., 8 bits for Single Precision): The power of 2 by which the number is scaled, stored with a bias to handle negative exponents.

  • Mantissa / Fraction (e.g., 23 bits for Single Precision): The significant digits of the number.

IEEE 754 binary32 field layout

Binary32 uses one sign bit, eight exponent bits, and twenty-three fraction bits. The exponent bias and special patterns determine interpretation for zero, subnormal values, infinities, and NaNs.

The 32-bit format is divided into one sign bit, eight exponent bits, and twenty-three fraction bits.

3. Syntax and Semantics

Just like human languages, programming languages have rules.

Key Concepts

  • Syntax: The set of rules that define the structure of the language (grammar). If syntax is wrong, the code won't compile or run (Syntax Error).

  • Semantics: The meaning of the instructions. Code can be syntactically correct but semantically wrong, producing incorrect results (Logic Error or Bug).

4. Variables and Data Types

Variable

A Variable is a named storage location in the computer's memory that holds a value. Think of it as a container with a label.

Variable Scope

Variable Scope defines the region of the code where a variable is accessible. A Local Variable is only accessible within the block or function where it was declared, whereas a Global Variable is accessible throughout the entire program.

4.1 Declaring Variables and Typing Systems

Variables are essential because they allow your program to be dynamic. Instead of writing code that only calculates the area for a radius of 5, you can write code that calculates the area for a variable named radius, which can hold any user input.

Typing Systems

  • Statically Typed (e.g., C++, Java): You must declare the data type of the variable upfront. The type is checked at compile-time.

  • Dynamically Typed (e.g., Python, JavaScript): The data type is inferred automatically at runtime based on the assigned value.

  • Strongly vs. Weakly Typed: Strongly typed languages enforce strict type rules (e.g., you cannot add an integer to a string), while weakly typed languages perform implicit type conversions.

4.2 Common Data Types

Fundamental Data Types

  • Integer (int): Whole numbers without decimals (e.g., 10, -5, 0).

  • Floating Point (float/double): Numbers with decimal points (e.g., 3.14, -0.01). Stored using IEEE 754.

  • Character (char): Single letter, number, or symbol (e.g., 'a', '7', '$'). Stored using ASCII/Unicode.

  • Boolean (bool): Represents truth values: True (1) or False (0).

  • String: A sequence of characters (text) (e.g., "Hello World"). Note: In some languages like C, strings are technically arrays of characters.

5. Operators

Operators are special symbols that perform operations on variables and values.

5.1 Arithmetic Operators

Used for mathematical calculations.

Arithmetic Rules

  • Addition (+): 5 + 3 = 8
  • Subtraction (-): 5 - 3 = 2
  • Multiplication (*): 5 * 3 = 15
  • Division (/): 10 / 2 = 5 (In languages like Python 3, / always returns a float. In C++, integer division truncates decimals).
  • Modulus (%): Returns the remainder of division. 10 % 3 = 1. Useful for determining even/odd numbers (x % 2 == 0).

5.2 Comparison (Relational) Operators

Used to compare two values. They return a boolean result (True/False).

Comparison Operators

  • Equal to (==): Checks if two values are equal. (Do not confuse with assignment =).

  • Not Equal to (!=): Checks if two values are not equal.

  • Greater Than (>): Checks if the left value is greater than the right.

  • Less Than (<): Checks if the left value is less than the right.

  • Greater/Equal (>=): Checks if left is greater than or equal to right.

  • Less/Equal (<=): Checks if left is less than or equal to right.

5.3 Logical Operators

Used to combine multiple boolean conditions.

Logic Rules

  • AND (&& or and): Returns True if both conditions are True.
  • OR (|| or or): Returns True if at least one condition is True.
  • NOT (! or not): Reverses the boolean value. (True becomes False).

5.4 Assignment and Bitwise Operators

Advanced Operators

  • Assignment (=): Assigns the value on the right to the variable on the left. Compound assignment operators like += (e.g., x += 5 is x = x + 5) are common.

  • Bitwise Operators (&, |, ^, ~, <<, >>): Perform operations directly on the binary bits of integers. Used in low-level programming and optimization.

6. Input and Output (I/O)

Programs need to interact with the user or the operating system to be useful.

6.1 Output (Printing)

Displaying information to the screen (standard output), writing to a file, or sending data over a network. Example: print("Hello") in Python or std::cout << "Hello"; in C++.

6.2 Input (Reading)

Getting information from the user via a keyboard (standard input), reading from a file, or receiving network packets. Example: input() in Python or std::cin >> variable; in C++.

Key Takeaways
  • Compilers translate the entire program into machine code before execution, resulting in faster runtime speeds.
  • Interpreters translate code line-by-line during execution, resulting in easier debugging but slower execution.
  • Hybrid languages compile to bytecode and use virtual machines for cross-platform portability.
  • Negative numbers are commonly stored using Two's Complement, where the leftmost bit indicates the sign.
  • Integer Overflow can cause unexpected behavior if calculations exceed representation limits.
  • Text is mapped to binary using standards like ASCII (English only) and Unicode/UTF-8 (global characters).
  • Fractional decimals are stored using the IEEE 754 Floating-Point Standard, splitting the number into a sign, exponent, and mantissa.
  • Syntax refers to the strict grammar rules of a programming language; code will not compile or run if syntax is incorrect.
  • Semantics refers to the logic and meaning behind the code; syntactically correct code can still have semantic errors (bugs).
  • Variables act as named memory locations to store and manipulate data dynamically during program execution, with strict scope rules dictating where they can be accessed.
  • Fundamental data types define the kind of data stored, such as integers (int), decimals (float/double), characters (char), and truth values (bool).
  • Languages differ in typing systems: static vs. dynamic, strong vs. weak.
  • Arithmetic operators (+, -, *, /, %) are used to perform mathematical calculations.
  • Relational operators (==, >, <, !=) compare values and return boolean results.
  • Logical operators (AND, OR, NOT) combine multiple conditions to control program flow.
  • Output operations (like 'cout' or 'print') display information to the user interface or screen.
  • Input operations (like 'cin' or 'input()') allow programs to receive dynamic data from the user during execution.
  • Language implementations may compile, interpret, or combine both methods; compiled targets can be native code or an intermediate representation.
  • Data is fundamentally represented as binary bits; negative numbers use Two's Complement, text uses ASCII/Unicode, and decimals use IEEE 754 Floating-Point.
  • Syntax refers to the grammar of the language, while Semantics refers to the logic/meaning.
  • Variables store data and are defined by specific Data Types (int, float, char, bool) and are governed by the language's typing system.
  • Operators manipulate data arithmetically (+, -, *, /), compare values (==, !=, >), and evaluate logic (AND, OR, NOT).
  • I/O Operations allow dynamic interaction with the user and environment.

References