The Big Idea: What is Programming?
At its core, programming is giving a computer a set of instructions to perform a
specific task.
Computers are incredibly fast and obedient, but they are also incredibly literal. They do
*exactly* what you tell them to do, not what you *mean* for them to do. Precision is key.
Core Concept 1: Variables
Think of a variable as a **labeled box** where you can store a piece of information.
* The Label: This is the variable name (e.g., `userAge`, `playerScore`, `firstName`).
* The Contents: This is the value stored inside (e.g., `25`, `10500`, `"Alice"`).
You can put things in the box, look at what's inside, or change the contents. The program
uses the label to find the value.
Example:`score = 10` means "put the value `10` into the box labeled `score`."
Core Concept 2: Data Types
Data comes in different forms. The "type" of data tells the computer what kind of thing it is
and what you can do with it. The most basic types are:
* Integers: Whole numbers (e.g., `-5`, `0`, `42`). Used for counting.
* Floats (or Decimals): Numbers with a decimal point (e.g., `3.14`, `-0.001`, `2.0`). Used
for precise measurements.
* Strings: A sequence of characters (text) surrounded by quotes (e.g., `"Hello World"`,
`"a"`, `"123"`). Note that `"123"` as a string is text, not a number you can do math on.
* **Booleans:** Represents a logical value. It can only be **True** or **False**. This is the
foundation of decision-making.
Core Concept 3: Control Structures
This is how you control the **flow** of your program's instructions. Instead of just running
from top to bottom, you can make decisions and repeat actions.
A) Conditional Statements: Making Choices
This lets your program ask a yes/no question and choose a path based on the answer. The
most common is the If-Then-Else statement.
Example
IF (it is raining) THEN
(take an umbrella)
ELSE
(wear sunglasses)
END IF
The computer evaluates the condition (`it is raining`). If it's True, it follows the first set of
instructions. If it's False, it follows the second.
B) Loops: Repeating Actions
Loops let you run the same piece of code multiple times without writing it out over and over.
* For Loop: Used when you know how many times you want to repeat something.
Example: "For each of the 10 students in the class, print their report card."
* While Loop: Used when you want to repeat something as long as a condition is
true.
Example: "While the battery is not full, keep charging." You don't know how long it
will take, you just know the condition to keep going.
Core Concept 4: Functions (or Methods/Procedures)
A function is a reusable block of code that performs a specific task. Think of it as a
custom command you create.
Why are functions useful?
1. Reusability: Write the code once, use it many times.
2. Organization: Break a complex problem into smaller, manageable pieces.
Analogy: Making a sandwich.
* You could list every step each time: "Get bread, open jar, spread peanut butter..."
* Or, you could define a function called `makePBJSandwich()`. Now, whenever you need a
sandwich, you just "call" that one command.
Functions can also take inputs (called parameters or arguments) and return an
output.
* `makeSandwich(bread, filling)` takes inputs for bread type and filling.
* `calculateArea(length, width)` takes inputs and **returns** the calculated area as an
output.
Core Concept 5: Data Structures
While a variable holds one piece of data, data structures are ways to store and organize
multiple pieces of data together.
A) Array / List: An ordered collection of items. Like a train where each car has a number.
* `shoppingList = ["milk", "eggs", "bread"]`
* You access items by their **position** (e.g., `shoppingList[0]` is `"milk"`).
B) Dictionary / Map / Object: A collection of key-value pairs. Like a real-world dictionary,
where you look up a word (the key) to find its definition (the value).
* phonebook = { "Alice": "555-1234", "Bob": "555-5678" }`
* You access items by their **unique key** (e.g., `phonebook["Alice"]` gives you
`"555-1234"`).
Core Concept 6: Basic Operations
You can perform operations on your data.
* Arithmetic: `+`, `-`, `*`, `/` (Addition, Subtraction, Multiplication, Division)
* Comparison: `==` (equal to), `!=` (not equal to), `>`, `<`, `>=`, `<=`. These produce a
Boolean (True/False) result, which is essential for `IF` statements and loops.
* Logical: `AND`, `OR`, `NOT`. Used to combine multiple conditions.
* `IF (isRaining AND hasUmbrella) THEN ...` (Both must be True)
* `IF (isWeekend OR isHoliday) THEN ...` (At least one must be True)
Core Concept 7: Input and Output (I/O)
This is how the program communicates with the outside world.
* Input: Getting data *into* the program (e.g., from a keyboard, a mouse click, a file, a
sensor).
* Output: Sending data *out* of the program (e.g., to a screen, a printer, a file, a speaker).
Putting It All Together: A Simple "Pseudocode"
Let's describe a program that greets a user and checks if they are an adult, using the
concepts above.
1. OUTPUT: Print "What is your name?" to the screen.
2. INPUT: Get the user's typing and store it in a variable called `name`.
3. OUTPUT: Print "Hello, " + `name` (This uses string combination).
4. OUTPUT: Print "How old are you?"
5. INPUT: Get the user's typing and store it in a variable called `age`.
6. CONDITIONAL (If-Then-Else):
IF age >= 18 THEN
OUTPUT: Print "You are an adult."
ELSE
OUTPUT: Print "You are a minor."
END IF
The Programmer's Mindset
Problem Decomposition: The single most important skill. You break a big, complex
problem ("I want a website") into smaller and smaller pieces until each piece is a solvable
task ("display text here", "get user input there").
Debugging: Your code will have mistakes (bugs). Debugging is the process of finding and
fixing them. It's a detective game, not a failure.
Precision: Remember, the computer is literal. Spelling, capitalization, and punctuation
matter immensely.
