Expand activity37 with comprehensive fundamental explanations
- Increased from 1,148 to 1,895 lines (+65%) - Added detailed explanations before each coding exercise - Enhanced Hello World section with stdout concepts and multi-language examples - Expanded Variables section with box analogy, naming rules, and typing differences - Enhanced Data Types with comprehensive type explanations and string formatting - Expanded If Statements with conditional logic fundamentals and comparison operators - Enhanced Loops with detailed for loop explanations, execution traces, and common patterns - Expanded Functions with DRY principle, parameter explanations, and best practices - Enhanced Return Values with display vs return differences and common mistakes - All sections now teach fundamentals thoroughly before asking students to code - Validation passed successfully
This commit is contained in:
Claude
parent
9ad911c615
commit
3ef98143b2
1 changed files with 791 additions and 43 deletions
|
|
@ -112,11 +112,41 @@ sections:
|
|||
title: Displaying Output
|
||||
content_blocks:
|
||||
- '## Your First Program: Hello World! 👋'
|
||||
- The traditional first program in any language is 'Hello World' - a program that displays text to the screen.
|
||||
- ''
|
||||
- '**In programming, we use stdout (standard output) to display messages.**'
|
||||
- '### What is "Hello World"?'
|
||||
- The traditional first program in any language is 'Hello World' - a program that displays text to the screen. This tradition dates back to the 1970s and serves as a simple test that your programming environment is working correctly.
|
||||
- ''
|
||||
- 'Different languages have different ways to write to stdout, but they all do the same thing: show text to the user.'
|
||||
- '### Understanding Standard Output (stdout)'
|
||||
- '**What is stdout?** Standard output (stdout) is the default destination where programs send their text output. When you run a program in a terminal or console, stdout is what displays on the screen.'
|
||||
- ''
|
||||
- '**Why is this important?** Almost every program needs to communicate with its users. Whether it''s displaying results, showing error messages, or presenting information, stdout is the fundamental way programs "talk" to people.'
|
||||
- ''
|
||||
- '### How Different Languages Display Output'
|
||||
- 'Every programming language has its own syntax, but they all accomplish the same goal. Here are examples across different languages:'
|
||||
- ''
|
||||
- '**Python:** Uses `print()` function'
|
||||
- '```python'
|
||||
- 'print("Hello, World!")'
|
||||
- '```'
|
||||
- ''
|
||||
- '**JavaScript:** Uses `console.log()` function'
|
||||
- '```javascript'
|
||||
- 'console.log("Hello, World!");'
|
||||
- '```'
|
||||
- ''
|
||||
- '**Java:** Uses `System.out.println()` method'
|
||||
- '```java'
|
||||
- 'System.out.println("Hello, World!");'
|
||||
- '```'
|
||||
- ''
|
||||
- '**C++:** Uses `std::cout` stream'
|
||||
- '```cpp'
|
||||
- 'std::cout << "Hello, World!" << std::endl;'
|
||||
- '```'
|
||||
- ''
|
||||
- '**Key Concept:** Notice that while the syntax differs, each language has a way to send text to stdout. The quotes around "Hello, World!" indicate it''s a **string** (text data).'
|
||||
- ''
|
||||
- '### Now It''s Your Turn!'
|
||||
question: How do you display 'Hello, World!' to stdout in your chosen language? Write the complete code.
|
||||
tokens_for_ai: 'IMPORTANT: Get the student''s chosen language from metadata (programming_language).
|
||||
|
||||
|
|
@ -226,9 +256,39 @@ sections:
|
|||
title: Multiple Outputs
|
||||
content_blocks:
|
||||
- '## Displaying Multiple Lines'
|
||||
- Great! Now let's display multiple messages.
|
||||
- ''
|
||||
- You can write to stdout multiple times in a row to display several lines of text.
|
||||
- '### Building on What You''ve Learned'
|
||||
- Great! Now that you can display one message, let's display multiple messages. This is a fundamental skill because real programs often need to show multiple pieces of information.
|
||||
- ''
|
||||
- '### Two Ways to Display Multiple Lines'
|
||||
- ''
|
||||
- '**Method 1: Multiple Output Statements**'
|
||||
- You can call your output function multiple times in sequence. Each call displays one line.
|
||||
- ''
|
||||
- '**Example in Python:**'
|
||||
- '```python'
|
||||
- 'print("First line")'
|
||||
- 'print("Second line")'
|
||||
- 'print("Third line")'
|
||||
- '```'
|
||||
- ''
|
||||
- '**Method 2: Newline Characters**'
|
||||
- Many languages support special characters like `\n` (newline) that create line breaks within a single string.
|
||||
- ''
|
||||
- '**Example in Python:**'
|
||||
- '```python'
|
||||
- 'print("First line\nSecond line\nThird line")'
|
||||
- '```'
|
||||
- ''
|
||||
- '### Understanding Newlines'
|
||||
- The `\n` is called an "escape sequence" - a special character that represents a line break. When the computer sees `\n`, it moves to the next line.'
|
||||
- ''
|
||||
- '**Why use multiple statements vs newlines?**'
|
||||
- '- Multiple statements are clearer and easier to read'
|
||||
- '- Newlines are more compact and useful when you have a long block of text'
|
||||
- '- Both are valid approaches!'
|
||||
- ''
|
||||
- '### Now It''s Your Turn!'
|
||||
question: 'Write a program that displays three lines to stdout: ''My first program'', ''Learning to code'', and ''This is fun!'' (each on its own line)'
|
||||
tokens_for_ai: 'The student should write code in THEIR chosen language (from metadata) that outputs three lines.
|
||||
|
||||
|
|
@ -323,15 +383,78 @@ sections:
|
|||
title: Creating Variables
|
||||
content_blocks:
|
||||
- '## Variables: Storing Information 📦'
|
||||
- Variables let you store and reuse data in your programs.
|
||||
- ''
|
||||
- '### What Are Variables?'
|
||||
- Variables are one of the most fundamental concepts in programming. A variable is a named storage location in your computer''s memory that holds a value. Think of it as a labeled container where you can store information and retrieve it later.
|
||||
- ''
|
||||
- '### Why Do We Need Variables?'
|
||||
- Imagine if you could only work with literal values. You''d have to write "Alice" everywhere you need that name. But with a variable, you write the name once, and then use the variable name to refer to it. This makes your code:'
|
||||
- '- **Reusable:** Use the same value in multiple places'
|
||||
- '- **Maintainable:** Change the value in one place, and it updates everywhere'
|
||||
- '- **Dynamic:** The value can change while the program runs'
|
||||
- '- **Readable:** `username` is clearer than "alice123"'
|
||||
- ''
|
||||
- '### The Box Analogy'
|
||||
- '**Think of a variable as a labeled box:**'
|
||||
- '- The label is the variable name'
|
||||
- '- The contents is the value'
|
||||
- '- You can look inside the box (read the value)'
|
||||
- '- You can change what''s inside (update the value)'
|
||||
- '- **The label** = the variable name (like `name`, `age`, `score`)'
|
||||
- '- **The contents** = the value stored inside (like `"Alice"`, `25`, `100`)'
|
||||
- '- **Reading** = looking inside the box to see what''s there'
|
||||
- '- **Writing/Updating** = putting new contents in the box'
|
||||
- ''
|
||||
- Different languages have different syntax for creating variables, but the concept is universal.
|
||||
- '### Variable Naming Rules'
|
||||
- 'Most languages follow similar rules for naming variables:'
|
||||
- '- Start with a letter or underscore (not a number)'
|
||||
- '- Can contain letters, numbers, and underscores'
|
||||
- '- Cannot use reserved words (like `if`, `for`, `while`)'
|
||||
- '- **Case-sensitive:** `name` and `Name` are different variables'
|
||||
- ''
|
||||
- '**Good names:** `user_name`, `total_score`, `isActive`, `playerHealth`'
|
||||
- '**Bad names:** `x`, `temp`, `asdf`, `thing1`'
|
||||
- ''
|
||||
- '### How to Create Variables in Different Languages'
|
||||
- ''
|
||||
- '**Python (dynamically typed):**'
|
||||
- '```python'
|
||||
- 'name = "Alice" # Create variable and assign value'
|
||||
- 'print(name) # Display the variable''s value'
|
||||
- '```'
|
||||
- ''
|
||||
- '**JavaScript (dynamically typed):**'
|
||||
- '```javascript'
|
||||
- 'let name = "Alice"; // Declare with let'
|
||||
- 'console.log(name); // Display'
|
||||
- '```'
|
||||
- ''
|
||||
- '**Java (statically typed):**'
|
||||
- '```java'
|
||||
- 'String name = "Alice"; // Must specify type'
|
||||
- 'System.out.println(name); // Display'
|
||||
- '```'
|
||||
- ''
|
||||
- '**C++ (statically typed):**'
|
||||
- '```cpp'
|
||||
- 'std::string name = "Alice"; // Must specify type'
|
||||
- 'std::cout << name << std::endl; // Display'
|
||||
- '```'
|
||||
- ''
|
||||
- '### Key Differences'
|
||||
- '**Dynamically typed languages** (Python, JavaScript, Ruby): You don''t declare the type. The language figures it out automatically.'
|
||||
- ''
|
||||
- '**Statically typed languages** (Java, C++, C#, Go): You must specify the type (String, int, etc.) when creating a variable.'
|
||||
- ''
|
||||
- '### The Assignment Operator'
|
||||
- 'The `=` sign is the **assignment operator**. It means "assign the value on the right to the variable on the left."'
|
||||
- ''
|
||||
- '```'
|
||||
- 'name = "Alice"'
|
||||
- '│ │'
|
||||
- '│ └── The value (what goes in the box)'
|
||||
- '└── The variable name (the label on the box)'
|
||||
- '```'
|
||||
- ''
|
||||
- '**Important:** In programming, `=` means assignment, NOT mathematical equality! To test equality, most languages use `==`.'
|
||||
- ''
|
||||
- '### Now It''s Your Turn!'
|
||||
question: Write a program that creates a variable called 'name' with your name as the value, then displays it to stdout.
|
||||
tokens_for_ai: 'Check that student writes code in THEIR language that:
|
||||
|
||||
|
|
@ -438,15 +561,108 @@ sections:
|
|||
title: Data Types
|
||||
content_blocks:
|
||||
- '## Understanding Data Types'
|
||||
- 'Variables can hold different types of data:'
|
||||
- ''
|
||||
- '**Common data types:**'
|
||||
- '- **Strings:** Text ("hello")'
|
||||
- '- **Integers:** Whole numbers (42)'
|
||||
- '- **Floats/Decimals:** Numbers with decimal points (3.14)'
|
||||
- '- **Booleans:** True or false values'
|
||||
- '### What Are Data Types?'
|
||||
- 'Just as in real life we have different kinds of information (names, ages, prices, yes/no answers), programming has different **data types** to represent different kinds of values. The type of data determines what operations you can perform on it.'
|
||||
- ''
|
||||
- Some languages require you to specify the type (statically typed), others figure it out automatically (dynamically typed).
|
||||
- '### Why Data Types Matter'
|
||||
- 'Data types tell the computer:'
|
||||
- '- How much memory to allocate'
|
||||
- '- What operations are valid (you can add numbers, but adding text doesn''t make mathematical sense)'
|
||||
- '- How to interpret the bits in memory'
|
||||
- ''
|
||||
- 'For example: `"25" + "10"` (strings) might give `"2510"` (concatenation), but `25 + 10` (numbers) gives `35` (addition).'
|
||||
- ''
|
||||
- '### The Four Fundamental Data Types'
|
||||
- ''
|
||||
- '**1. Strings (Text)**'
|
||||
- '- Represent text and characters'
|
||||
- '- Enclosed in quotes: `"hello"`, `''world''`, `"Alice"`'
|
||||
- '- Can contain letters, numbers, spaces, symbols'
|
||||
- '- Examples: names, addresses, messages, file paths'
|
||||
- ''
|
||||
- '**2. Integers (Whole Numbers)**'
|
||||
- '- Whole numbers without decimal points'
|
||||
- '- Can be positive, negative, or zero'
|
||||
- '- Examples: `42`, `-17`, `0`, `1000`'
|
||||
- '- Used for: counting, indexing, discrete quantities'
|
||||
- ''
|
||||
- '**3. Floats/Doubles (Decimal Numbers)**'
|
||||
- '- Numbers with decimal points'
|
||||
- '- More precision for measurements'
|
||||
- '- Examples: `3.14`, `-0.5`, `2.71828`, `1.75`'
|
||||
- '- Used for: measurements, prices, scientific calculations'
|
||||
- '- Note: "Float" = single precision, "Double" = double precision'
|
||||
- ''
|
||||
- '**4. Booleans (True/False)**'
|
||||
- '- Only two possible values: `true` or `false`'
|
||||
- '- Used for: decisions, conditions, flags'
|
||||
- '- Examples: `isActive`, `hasPermission`, `gameOver`'
|
||||
- '- We''ll use these heavily with if statements later!'
|
||||
- ''
|
||||
- '### Static vs Dynamic Typing'
|
||||
- ''
|
||||
- '**Statically Typed Languages** (Java, C++, C#, Go, Rust):'
|
||||
- '- You MUST declare the type when creating a variable'
|
||||
- '- Type cannot change after declaration'
|
||||
- '- Catches type errors before the program runs'
|
||||
- ''
|
||||
- '**Example in Java:**'
|
||||
- '```java'
|
||||
- 'int age = 25; // Integer type'
|
||||
- 'double height = 1.75; // Decimal type'
|
||||
- 'String city = "Tokyo"; // String type'
|
||||
- 'boolean isStudent = true; // Boolean type'
|
||||
- '```'
|
||||
- ''
|
||||
- '**Dynamically Typed Languages** (Python, JavaScript, Ruby, PHP):'
|
||||
- '- Type is inferred automatically from the value'
|
||||
- '- Variables can hold different types at different times'
|
||||
- '- More flexible but less type safety'
|
||||
- ''
|
||||
- '**Example in Python:**'
|
||||
- '```python'
|
||||
- 'age = 25 # Python knows it''s an integer'
|
||||
- 'height = 1.75 # Python knows it''s a float'
|
||||
- 'city = "Tokyo" # Python knows it''s a string'
|
||||
- 'is_student = True # Python knows it''s a boolean'
|
||||
- '```'
|
||||
- ''
|
||||
- '### Combining Strings and Variables in Output'
|
||||
- 'When displaying variables with labels, you need to combine strings and values. Different languages have different approaches:'
|
||||
- ''
|
||||
- '**Python - f-strings (modern):**'
|
||||
- '```python'
|
||||
- 'age = 25'
|
||||
- 'print(f"Age: {age}") # Output: Age: 25'
|
||||
- '```'
|
||||
- ''
|
||||
- '**JavaScript - template literals:**'
|
||||
- '```javascript'
|
||||
- 'let age = 25;'
|
||||
- 'console.log(`Age: ${age}`); // Output: Age: 25'
|
||||
- '```'
|
||||
- ''
|
||||
- '**Java - concatenation:**'
|
||||
- '```java'
|
||||
- 'int age = 25;'
|
||||
- 'System.out.println("Age: " + age); // Output: Age: 25'
|
||||
- '```'
|
||||
- ''
|
||||
- '**C++ - stream insertion:**'
|
||||
- '```cpp'
|
||||
- 'int age = 25;'
|
||||
- 'std::cout << "Age: " << age << std::endl; // Output: Age: 25'
|
||||
- '```'
|
||||
- ''
|
||||
- '### Type Conversion'
|
||||
- 'Sometimes you need to convert between types:'
|
||||
- '- String to number: `int("25")` (Python), `parseInt("25")` (JavaScript)'
|
||||
- '- Number to string: `str(25)` (Python), `String.valueOf(25)` (Java)'
|
||||
- '- Integer to float: Usually automatic in most languages'
|
||||
- ''
|
||||
- '### Now It''s Your Turn!'
|
||||
- 'Practice working with multiple data types by creating variables of different types and displaying them with descriptive labels.'
|
||||
question: 'Write a program with three variables: an integer (age), a decimal/float (height in meters), and a string (city). Display all three with labels, like ''Age: 25'', ''Height: 1.75'', ''City: Tokyo'''
|
||||
tokens_for_ai: 'Check that student creates three variables of different types and outputs them with labels.
|
||||
|
||||
|
|
@ -563,14 +779,120 @@ sections:
|
|||
- step_id: step_1
|
||||
title: If Statements
|
||||
content_blocks:
|
||||
- '## Conditional Logic 🔀'
|
||||
- Programs need to make decisions based on conditions.
|
||||
- '## Conditional Logic: Making Decisions 🔀'
|
||||
- ''
|
||||
- '**If statements** let your code take different paths:'
|
||||
- '- IF condition is true, do this'
|
||||
- '- ELSE, do that'
|
||||
- '### What Is Conditional Logic?'
|
||||
- 'Up until now, your programs have been linear - they execute every line in order from top to bottom. But real programs need to make **decisions** based on different situations. This is called **conditional logic** or **branching**.'
|
||||
- ''
|
||||
- This is how programs respond to different situations!
|
||||
- '### Why Do We Need Conditionals?'
|
||||
- 'Think about everyday decisions:'
|
||||
- '- "IF it''s raining, take an umbrella. ELSE, leave it at home."'
|
||||
- '- "IF you have enough money, buy the item. ELSE, save up more."'
|
||||
- '- "IF the user is logged in, show their dashboard. ELSE, show the login page."'
|
||||
- ''
|
||||
- 'Programs need to make similar decisions based on the current state or user input.'
|
||||
- ''
|
||||
- '### The If Statement'
|
||||
- 'An **if statement** tests a **condition** (something that evaluates to true or false) and executes code only if that condition is true.'
|
||||
- ''
|
||||
- '**Basic structure:**'
|
||||
- '```'
|
||||
- 'IF condition is true:'
|
||||
- ' execute this code'
|
||||
- '```'
|
||||
- ''
|
||||
- '**With else:**'
|
||||
- '```'
|
||||
- 'IF condition is true:'
|
||||
- ' execute this code'
|
||||
- 'ELSE:'
|
||||
- ' execute this other code'
|
||||
- '```'
|
||||
- ''
|
||||
- '### Comparison Operators'
|
||||
- 'To test conditions, we use **comparison operators** that compare two values and return true or false:'
|
||||
- ''
|
||||
- '- `==` Equal to (Note: double equals for comparison, single = for assignment!)'
|
||||
- '- `!=` Not equal to'
|
||||
- '- `>` Greater than'
|
||||
- '- `<` Less than'
|
||||
- '- `>=` Greater than or equal to'
|
||||
- '- `<=` Less than or equal to'
|
||||
- ''
|
||||
- '**Examples:**'
|
||||
- '- `age >= 18` → true if age is 18 or more, false otherwise'
|
||||
- '- `score == 100` → true if score is exactly 100'
|
||||
- '- `temperature > 30` → true if temperature exceeds 30'
|
||||
- ''
|
||||
- '### If/Else in Different Languages'
|
||||
- ''
|
||||
- '**Python:**'
|
||||
- '```python'
|
||||
- 'age = 20'
|
||||
- 'if age >= 18:'
|
||||
- ' print("Adult")'
|
||||
- 'else:'
|
||||
- ' print("Minor")'
|
||||
- '```'
|
||||
- 'Note: Python uses **indentation** to show which code belongs to the if/else blocks. Colons (`:`) start each block.'
|
||||
- ''
|
||||
- '**JavaScript:**'
|
||||
- '```javascript'
|
||||
- 'let age = 20;'
|
||||
- 'if (age >= 18) {'
|
||||
- ' console.log("Adult");'
|
||||
- '} else {'
|
||||
- ' console.log("Minor");'
|
||||
- '}'
|
||||
- '```'
|
||||
- 'Note: Curly braces `{}` group the code blocks. Condition must be in parentheses `()`.'
|
||||
- ''
|
||||
- '**Java:**'
|
||||
- '```java'
|
||||
- 'int age = 20;'
|
||||
- 'if (age >= 18) {'
|
||||
- ' System.out.println("Adult");'
|
||||
- '} else {'
|
||||
- ' System.out.println("Minor");'
|
||||
- '}'
|
||||
- '```'
|
||||
- 'Similar to JavaScript - uses braces and parentheses.'
|
||||
- ''
|
||||
- '**C++:**'
|
||||
- '```cpp'
|
||||
- 'int age = 20;'
|
||||
- 'if (age >= 18) {'
|
||||
- ' std::cout << "Adult" << std::endl;'
|
||||
- '} else {'
|
||||
- ' std::cout << "Minor" << std::endl;'
|
||||
- '}'
|
||||
- '```'
|
||||
- ''
|
||||
- '### Multiple Conditions (Else If)'
|
||||
- 'You can chain multiple conditions using else-if:'
|
||||
- ''
|
||||
- '```python'
|
||||
- 'if age < 13:'
|
||||
- ' print("Child")'
|
||||
- 'elif age < 18: # else if in Python'
|
||||
- ' print("Teen")'
|
||||
- 'else:'
|
||||
- ' print("Adult")'
|
||||
- '```'
|
||||
- ''
|
||||
- '### How the Computer Evaluates Conditionals'
|
||||
- '1. Evaluate the condition (does it produce true or false?)'
|
||||
- '2. If true, execute the if block and skip the else'
|
||||
- '3. If false, skip the if block and execute the else'
|
||||
- '4. Continue with the rest of the program'
|
||||
- ''
|
||||
- '### Boolean Logic'
|
||||
- 'Remember boolean data types? Conditions always evaluate to a boolean:'
|
||||
- '- `age >= 18` → evaluates to `true` or `false`'
|
||||
- '- You can also use boolean variables directly: `if isLoggedIn:`'
|
||||
- ''
|
||||
- '### Now It''s Your Turn!'
|
||||
- 'Practice conditional logic by writing an if/else statement that checks age and displays different messages.'
|
||||
question: 'Write a program that: creates a variable for age, then uses an if/else statement to display ''Adult'' if age is 18 or older, or ''Minor'' if younger. Test with age = 20.'
|
||||
tokens_for_ai: 'Check their if/else code in their chosen language.
|
||||
|
||||
|
|
@ -677,13 +999,129 @@ sections:
|
|||
title: Loops
|
||||
content_blocks:
|
||||
- '## Loops: Repeating Actions 🔁'
|
||||
- Loops let you repeat code multiple times without writing it over and over.
|
||||
- ''
|
||||
- '**Common loop types:**'
|
||||
- '- **For loop:** Repeat a specific number of times'
|
||||
- '- **While loop:** Repeat as long as a condition is true'
|
||||
- '### What Are Loops?'
|
||||
- 'Imagine you want to display numbers 1 through 1000. Would you write 1000 print statements? Of course not! **Loops** let you repeat code multiple times without writing it over and over.'
|
||||
- ''
|
||||
- Loops are essential for processing lists, counting, and repetitive tasks.
|
||||
- '### Why Do We Need Loops?'
|
||||
- 'Loops are essential for:'
|
||||
- '- **Repetitive tasks:** Displaying numbers, processing items, running calculations'
|
||||
- '- **Collections:** Going through every element in a list or array'
|
||||
- '- **Automation:** Doing the same thing many times efficiently'
|
||||
- '- **Iteration:** Repeating until a goal is reached'
|
||||
- ''
|
||||
- 'Without loops, programs would be extremely limited and repetitive!'
|
||||
- ''
|
||||
- '### The Two Main Types of Loops'
|
||||
- ''
|
||||
- '**1. For Loop (Counting Loop)**'
|
||||
- '- Use when you know HOW MANY times to repeat'
|
||||
- '- Has a counter variable that changes each iteration'
|
||||
- '- Best for: counting, iterating a specific number of times'
|
||||
- ''
|
||||
- '**2. While Loop (Conditional Loop)**'
|
||||
- '- Use when you want to repeat UNTIL a condition becomes false'
|
||||
- '- Keeps going as long as the condition is true'
|
||||
- '- Best for: unknown number of repetitions, waiting for something to happen'
|
||||
- ''
|
||||
- '### For Loops in Detail'
|
||||
- 'A for loop typically has three parts:'
|
||||
- '1. **Initialization:** Set up a counter variable'
|
||||
- '2. **Condition:** When to stop looping'
|
||||
- '3. **Update:** How to change the counter after each iteration'
|
||||
- ''
|
||||
- '### For Loops in Different Languages'
|
||||
- ''
|
||||
- '**Python (using range):**'
|
||||
- '```python'
|
||||
- 'for i in range(1, 6): # Start at 1, stop before 6 (so 1,2,3,4,5)'
|
||||
- ' print(i)'
|
||||
- '```'
|
||||
- 'Python''s `range(start, stop)` generates numbers from start up to (but not including) stop.'
|
||||
- ''
|
||||
- '**JavaScript (C-style):**'
|
||||
- '```javascript'
|
||||
- 'for (let i = 1; i <= 5; i++) { // Start; Condition; Increment'
|
||||
- ' console.log(i);'
|
||||
- '}'
|
||||
- '```'
|
||||
- 'Breaking it down:'
|
||||
- '- `let i = 1` - Initialize counter to 1'
|
||||
- '- `i <= 5` - Keep going while i is 5 or less'
|
||||
- '- `i++` - Add 1 to i after each iteration (`++` means increment by 1)'
|
||||
- ''
|
||||
- '**Java (same as JavaScript):**'
|
||||
- '```java'
|
||||
- 'for (int i = 1; i <= 5; i++) {'
|
||||
- ' System.out.println(i);'
|
||||
- '}'
|
||||
- '```'
|
||||
- ''
|
||||
- '**C++ (same pattern):**'
|
||||
- '```cpp'
|
||||
- 'for (int i = 1; i <= 5; i++) {'
|
||||
- ' std::cout << i << std::endl;'
|
||||
- '}'
|
||||
- '```'
|
||||
- ''
|
||||
- '**Ruby:**'
|
||||
- '```ruby'
|
||||
- '(1..5).each do |i| # Range from 1 to 5'
|
||||
- ' puts i'
|
||||
- 'end'
|
||||
- '```'
|
||||
- ''
|
||||
- '**Go:**'
|
||||
- '```go'
|
||||
- 'for i := 1; i <= 5; i++ {'
|
||||
- ' fmt.Println(i)'
|
||||
- '}'
|
||||
- '```'
|
||||
- ''
|
||||
- '### How a For Loop Executes'
|
||||
- 'Let''s trace through `for (let i = 1; i <= 5; i++)`:'
|
||||
- ''
|
||||
- '1. **Iteration 1:** i=1, check 1<=5 (true), print 1, increment to i=2'
|
||||
- '2. **Iteration 2:** i=2, check 2<=5 (true), print 2, increment to i=3'
|
||||
- '3. **Iteration 3:** i=3, check 3<=5 (true), print 3, increment to i=4'
|
||||
- '4. **Iteration 4:** i=4, check 4<=5 (true), print 4, increment to i=5'
|
||||
- '5. **Iteration 5:** i=5, check 5<=5 (true), print 5, increment to i=6'
|
||||
- '6. **Check:** i=6, check 6<=5 (false), exit loop'
|
||||
- ''
|
||||
- '### The Loop Variable'
|
||||
- 'The variable `i` is called the **loop variable** or **counter**:'
|
||||
- '- Common names: `i`, `j`, `k` (for nested loops), or descriptive names like `count`, `index`'
|
||||
- '- It automatically updates each iteration'
|
||||
- '- You can use it inside the loop for calculations or display'
|
||||
- ''
|
||||
- '### Common Loop Patterns'
|
||||
- ''
|
||||
- '**Count from 0 to N-1:**'
|
||||
- '```python'
|
||||
- 'for i in range(5): # 0, 1, 2, 3, 4'
|
||||
- ' print(i)'
|
||||
- '```'
|
||||
- ''
|
||||
- '**Count by 2s:**'
|
||||
- '```python'
|
||||
- 'for i in range(0, 11, 2): # 0, 2, 4, 6, 8, 10'
|
||||
- ' print(i)'
|
||||
- '```'
|
||||
- ''
|
||||
- '**Count backwards:**'
|
||||
- '```python'
|
||||
- 'for i in range(5, 0, -1): # 5, 4, 3, 2, 1'
|
||||
- ' print(i)'
|
||||
- '```'
|
||||
- ''
|
||||
- '### Avoiding Infinite Loops'
|
||||
- 'Make sure your loop will eventually end! Common mistakes:'
|
||||
- '- Forgetting to increment the counter'
|
||||
- '- Wrong condition (using `<` when you need `>`)'
|
||||
- '- Modifying the counter incorrectly inside the loop'
|
||||
- ''
|
||||
- '### Now It''s Your Turn!'
|
||||
- 'Practice loops by writing a simple counting loop that displays numbers 1 through 5.'
|
||||
question: Write a program using a for loop that displays the numbers 1 through 5 to stdout, each on its own line.
|
||||
tokens_for_ai: 'Check their for loop code in their chosen language.
|
||||
|
||||
|
|
@ -810,18 +1248,153 @@ sections:
|
|||
- step_id: step_1
|
||||
title: Creating Functions
|
||||
content_blocks:
|
||||
- '## Functions: Organize Your Code 📦'
|
||||
- Functions let you group code into reusable blocks that you can call by name.
|
||||
- '## Functions: Organize and Reuse Your Code 📦'
|
||||
- ''
|
||||
- '**Benefits of functions:**'
|
||||
- '- Reusability (write once, use many times)'
|
||||
- '- Organization (break complex programs into manageable pieces)'
|
||||
- '- Abstraction (hide implementation details)'
|
||||
- '### What Are Functions?'
|
||||
- 'A **function** is a named block of reusable code that performs a specific task. Think of it as a mini-program within your program. Functions are one of the most important concepts in programming because they let you organize code and avoid repetition.'
|
||||
- ''
|
||||
- '**Functions can:**'
|
||||
- '- Take inputs (parameters/arguments)'
|
||||
- '- Perform actions'
|
||||
- '- Return outputs (return values)'
|
||||
- '### Why Do We Need Functions?'
|
||||
- ''
|
||||
- '**Without functions, code becomes:**'
|
||||
- '- Repetitive (copy-paste the same code everywhere)'
|
||||
- '- Hard to maintain (fix a bug in 50 places instead of 1)'
|
||||
- '- Difficult to understand (one giant block of code)'
|
||||
- '- Impossible to test in isolation'
|
||||
- ''
|
||||
- '**With functions, code becomes:**'
|
||||
- '- **Reusable:** Write once, use many times'
|
||||
- '- **Organized:** Break complex programs into manageable pieces'
|
||||
- '- **Readable:** `calculateTax()` is clearer than 50 lines of math'
|
||||
- '- **Testable:** Test each function independently'
|
||||
- '- **Abstract:** Hide implementation details behind a simple name'
|
||||
- ''
|
||||
- '### Real-World Analogy'
|
||||
- 'Think of functions like recipes in a cookbook:'
|
||||
- '- Each recipe has a **name** ("Chocolate Cake")'
|
||||
- '- Each recipe takes **ingredients** (inputs/parameters)'
|
||||
- '- Each recipe has **instructions** (the function body - what it does)'
|
||||
- '- Each recipe produces **a result** (output/return value)'
|
||||
- ''
|
||||
- 'You don''t rewrite the recipe every time you want cake - you just refer to it by name: "Make Chocolate Cake"'
|
||||
- ''
|
||||
- '### Anatomy of a Function'
|
||||
- ''
|
||||
- 'Every function has these parts:'
|
||||
- ''
|
||||
- '1. **Name:** What you call the function (`greet`, `calculateTotal`, `isValid`)'
|
||||
- '2. **Parameters:** Inputs the function needs (optional)'
|
||||
- '3. **Body:** The code that runs when you call the function'
|
||||
- '4. **Return value:** What the function sends back (optional)'
|
||||
- ''
|
||||
- '**Defining vs Calling:**'
|
||||
- '- **Definition** = Creating the function (writing the recipe)'
|
||||
- '- **Call** = Using the function (following the recipe)'
|
||||
- ''
|
||||
- '### Functions in Different Languages'
|
||||
- ''
|
||||
- '**Python:**'
|
||||
- '```python'
|
||||
- '# Define the function'
|
||||
- 'def greet(name): # def = define, name = parameter'
|
||||
- ' print(f"Hello, {name}!") # Function body (indented)'
|
||||
- ''
|
||||
- '# Call the function'
|
||||
- 'greet("Alice") # Output: Hello, Alice!'
|
||||
- 'greet("Bob") # Output: Hello, Bob!'
|
||||
- '```'
|
||||
- ''
|
||||
- '**JavaScript:**'
|
||||
- '```javascript'
|
||||
- '// Define the function'
|
||||
- 'function greet(name) { // function keyword'
|
||||
- ' console.log(`Hello, ${name}!`); // Function body in braces'
|
||||
- '}'
|
||||
- ''
|
||||
- '// Call the function'
|
||||
- 'greet("Alice"); // Output: Hello, Alice!'
|
||||
- 'greet("Bob"); // Output: Hello, Bob!'
|
||||
- '```'
|
||||
- ''
|
||||
- '**Java:**'
|
||||
- '```java'
|
||||
- '// Define the function (method)'
|
||||
- 'void greet(String name) { // void = no return value'
|
||||
- ' System.out.println("Hello, " + name + "!");'
|
||||
- '}'
|
||||
- ''
|
||||
- '// Call the function'
|
||||
- 'greet("Alice");'
|
||||
- 'greet("Bob");'
|
||||
- '```'
|
||||
- ''
|
||||
- '**C++:**'
|
||||
- '```cpp'
|
||||
- '// Define the function'
|
||||
- 'void greet(std::string name) { // void = no return'
|
||||
- ' std::cout << "Hello, " << name << "!" << std::endl;'
|
||||
- '}'
|
||||
- ''
|
||||
- '// Call the function'
|
||||
- 'greet("Alice");'
|
||||
- 'greet("Bob");'
|
||||
- '```'
|
||||
- ''
|
||||
- '### Understanding Parameters'
|
||||
- ''
|
||||
- '**Parameters** (also called arguments) are values you pass into a function:'
|
||||
- ''
|
||||
- '```python'
|
||||
- 'def greet(name): # "name" is a parameter'
|
||||
- ' print(f"Hello, {name}!")'
|
||||
- ''
|
||||
- 'greet("Alice") # "Alice" is the argument passed to name'
|
||||
- '```'
|
||||
- ''
|
||||
- 'When you call `greet("Alice")`:'
|
||||
- '1. The value `"Alice"` is passed to the function'
|
||||
- '2. Inside the function, `name = "Alice"`'
|
||||
- '3. The function can use `name` like any other variable'
|
||||
- ''
|
||||
- '**Multiple parameters:**'
|
||||
- '```python'
|
||||
- 'def greet(first_name, last_name):'
|
||||
- ' print(f"Hello, {first_name} {last_name}!")'
|
||||
- ''
|
||||
- 'greet("Alice", "Smith") # Output: Hello, Alice Smith!'
|
||||
- '```'
|
||||
- ''
|
||||
- '### The DRY Principle'
|
||||
- '**DRY = Don''t Repeat Yourself**'
|
||||
- ''
|
||||
- '**Without functions (repetitive):**'
|
||||
- '```python'
|
||||
- 'print("Hello, Alice!")'
|
||||
- 'print("Hello, Bob!")'
|
||||
- 'print("Hello, Carol!")'
|
||||
- '```'
|
||||
- ''
|
||||
- '**With functions (DRY):**'
|
||||
- '```python'
|
||||
- 'def greet(name):'
|
||||
- ' print(f"Hello, {name}!")'
|
||||
- ''
|
||||
- 'greet("Alice")'
|
||||
- 'greet("Bob")'
|
||||
- 'greet("Carol")'
|
||||
- '```'
|
||||
- ''
|
||||
- 'If you need to change the greeting format, you only change it in ONE place (the function), not everywhere it''s used!'
|
||||
- ''
|
||||
- '### Function Naming Conventions'
|
||||
- 'Choose clear, descriptive names that describe what the function does:'
|
||||
- ''
|
||||
- '**Good names:** `calculateTotal`, `isValid`, `getUserInput`, `sendEmail`'
|
||||
- '**Bad names:** `doStuff`, `func1`, `xyz`, `temp`'
|
||||
- ''
|
||||
- 'Use verb names since functions perform actions: `get`, `set`, `calculate`, `validate`, `send`, `display`'
|
||||
- ''
|
||||
- '### Now It''s Your Turn!'
|
||||
- 'Practice creating and calling a function with a parameter.'
|
||||
question: Write a function called 'greet' that takes a name as a parameter and displays 'Hello, [name]!' to stdout. Then call the function with your own name.
|
||||
tokens_for_ai: 'Check their function code in their chosen language.
|
||||
|
||||
|
|
@ -937,12 +1510,187 @@ sections:
|
|||
title: Return Values
|
||||
content_blocks:
|
||||
- '## Functions That Return Values'
|
||||
- So far, our function just displays output. Functions can also RETURN values that can be used elsewhere.
|
||||
- ''
|
||||
- '### Display vs Return: A Critical Difference'
|
||||
- 'So far, our `greet` function **displayed** output directly to stdout. But functions can also **return** values that can be used elsewhere. This is a crucial concept that many beginners find confusing at first.'
|
||||
- ''
|
||||
- '**Displaying (printing):**'
|
||||
- '- Shows output to the user immediately'
|
||||
- '- Cannot save or reuse the value'
|
||||
- '- The function''s only effect is to show text'
|
||||
- ''
|
||||
- '**Returning:**'
|
||||
- '- Sends a value back to the caller'
|
||||
- '- The caller can store it, use it in calculations, or display it'
|
||||
- '- More flexible and reusable'
|
||||
- ''
|
||||
- '### Why Return Values?'
|
||||
- ''
|
||||
- 'Imagine a calculator. It doesn''t just print results on paper - it gives you the answer so you can use it in the next calculation. That''s what return values do!'
|
||||
- ''
|
||||
- '**Return values let you:**'
|
||||
- '- Calculate something and send the result back'
|
||||
- '- Use the result in other calculations'
|
||||
- '- Store the result in a variable'
|
||||
- '- **Calculate and send back results:** `calculateTax(100)` returns `15`'
|
||||
- '- **Use results in other operations:** `total = price + calculateTax(price)`'
|
||||
- '- **Store results in variables:** `tax = calculateTax(price)`'
|
||||
- '- **Chain functions together:** `display(formatCurrency(calculateTotal(items)))`'
|
||||
- ''
|
||||
- '### Visualizing the Difference'
|
||||
- ''
|
||||
- '**Function that displays:**'
|
||||
- '```python'
|
||||
- 'def add(a, b):'
|
||||
- ' print(a + b) # Shows result but can''t reuse it'
|
||||
- ''
|
||||
- 'add(5, 3) # Displays: 8'
|
||||
- 'result = add(5, 3) # result = None (nothing returned!)'
|
||||
- '```'
|
||||
- ''
|
||||
- '**Function that returns:**'
|
||||
- '```python'
|
||||
- 'def add(a, b):'
|
||||
- ' return a + b # Sends result back to caller'
|
||||
- ''
|
||||
- 'result = add(5, 3) # result = 8 (can use it!)'
|
||||
- 'print(result) # Displays: 8'
|
||||
- 'double = result * 2 # Can do more calculations!'
|
||||
- '```'
|
||||
- ''
|
||||
- '### The Return Statement'
|
||||
- ''
|
||||
- 'The **return statement** does two things:'
|
||||
- '1. Sends a value back to whoever called the function'
|
||||
- '2. Immediately exits the function (no code after return runs)'
|
||||
- ''
|
||||
- '**Syntax in different languages:**'
|
||||
- '```python'
|
||||
- 'return value # Python'
|
||||
- '```'
|
||||
- '```javascript'
|
||||
- 'return value; // JavaScript, Java, C++, etc.'
|
||||
- '```'
|
||||
- ''
|
||||
- '### Return Values in Different Languages'
|
||||
- ''
|
||||
- '**Python:**'
|
||||
- '```python'
|
||||
- 'def add(a, b):'
|
||||
- ' return a + b'
|
||||
- ''
|
||||
- 'result = add(5, 3) # result = 8'
|
||||
- 'print(result) # Display the result'
|
||||
- '```'
|
||||
- ''
|
||||
- '**JavaScript:**'
|
||||
- '```javascript'
|
||||
- 'function add(a, b) {'
|
||||
- ' return a + b;'
|
||||
- '}'
|
||||
- ''
|
||||
- 'let result = add(5, 3);'
|
||||
- 'console.log(result); // Output: 8'
|
||||
- '```'
|
||||
- ''
|
||||
- '**Java:**'
|
||||
- '```java'
|
||||
- 'int add(int a, int b) { // int before name = return type'
|
||||
- ' return a + b;'
|
||||
- '}'
|
||||
- ''
|
||||
- 'int result = add(5, 3);'
|
||||
- 'System.out.println(result); // Output: 8'
|
||||
- '```'
|
||||
- 'Note: In statically typed languages like Java/C++, you must declare the return type!'
|
||||
- ''
|
||||
- '**C++:**'
|
||||
- '```cpp'
|
||||
- 'int add(int a, int b) { // int = return type'
|
||||
- ' return a + b;'
|
||||
- '}'
|
||||
- ''
|
||||
- 'int result = add(5, 3);'
|
||||
- 'std::cout << result << std::endl; // Output: 8'
|
||||
- '```'
|
||||
- ''
|
||||
- '### Understanding Return Types'
|
||||
- ''
|
||||
- '**Dynamically typed languages** (Python, JavaScript):'
|
||||
- '- Don''t declare return type'
|
||||
- '- Can return any type'
|
||||
- ''
|
||||
- '**Statically typed languages** (Java, C++, C#, Go):'
|
||||
- '- Must declare return type before function name'
|
||||
- '- `int add(...)` means function returns an integer'
|
||||
- '- `String getName(...)` means function returns a string'
|
||||
- '- `void doSomething(...)` means function returns nothing'
|
||||
- ''
|
||||
- '### Using Returned Values'
|
||||
- ''
|
||||
- 'Once a function returns a value, you can:'
|
||||
- ''
|
||||
- '**Store it in a variable:**'
|
||||
- '```python'
|
||||
- 'sum = add(5, 3) # sum = 8'
|
||||
- '```'
|
||||
- ''
|
||||
- '**Use it in calculations:**'
|
||||
- '```python'
|
||||
- 'total = add(5, 3) * 2 # total = 16'
|
||||
- '```'
|
||||
- ''
|
||||
- '**Pass it to another function:**'
|
||||
- '```python'
|
||||
- 'print(add(5, 3)) # Displays 8'
|
||||
- '```'
|
||||
- ''
|
||||
- '**Use it in conditionals:**'
|
||||
- '```python'
|
||||
- 'if add(5, 3) > 10:'
|
||||
- ' print("Big number!")'
|
||||
- '```'
|
||||
- ''
|
||||
- '### Common Mistakes'
|
||||
- ''
|
||||
- '**Mistake 1: Forgetting to return**'
|
||||
- '```python'
|
||||
- 'def add(a, b):'
|
||||
- ' a + b # Calculates but doesn''t return!'
|
||||
- ''
|
||||
- 'result = add(5, 3) # result = None ❌'
|
||||
- '```'
|
||||
- ''
|
||||
- '**Mistake 2: Printing instead of returning**'
|
||||
- '```python'
|
||||
- 'def add(a, b):'
|
||||
- ' print(a + b) # Displays but doesn''t return!'
|
||||
- ''
|
||||
- 'result = add(5, 3) # Shows 8, but result = None ❌'
|
||||
- '```'
|
||||
- ''
|
||||
- '**Correct:**'
|
||||
- '```python'
|
||||
- 'def add(a, b):'
|
||||
- ' return a + b # Returns the value ✓'
|
||||
- ''
|
||||
- 'result = add(5, 3) # result = 8 ✓'
|
||||
- '```'
|
||||
- ''
|
||||
- '### When to Display vs Return'
|
||||
- ''
|
||||
- '**Use display (print) when:**'
|
||||
- '- The function''s purpose is to show information to the user'
|
||||
- '- You won''t need the value later'
|
||||
- '- Example: `showWelcomeMessage()`, `displayReport()`'
|
||||
- ''
|
||||
- '**Use return when:**'
|
||||
- '- The function calculates a result you''ll use later'
|
||||
- '- You want flexibility (caller decides whether to display)'
|
||||
- '- You''re building reusable utility functions'
|
||||
- '- Example: `calculateTotal()`, `isValid()`, `formatName()`'
|
||||
- ''
|
||||
- '**Best practice:** Most functions should return values. Let the caller decide whether to display them.'
|
||||
- ''
|
||||
- '### Now It''s Your Turn!'
|
||||
- 'Practice creating a function that returns a value, then using that returned value.'
|
||||
question: Write a function called 'add' that takes two numbers as parameters, returns their sum, and then call it with 5 and 3 and display the result to stdout.
|
||||
tokens_for_ai: 'Check their function with return value.
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue