Chapter 3: Foundations of Programming: Review and Refresh

Introduction

Welcome back, future DSA master! In our previous chapters, we successfully set up our development environment with Node.js and TypeScript, getting us ready to write some amazing code. Now, before we dive headfirst into the exciting world of Data Structures and Algorithms, it’s crucial to ensure our programming foundations are rock solid.

This chapter is designed as a focused review and refresh of core programming concepts. Think of it as a quick warm-up for your coding muscles! We’ll cover fundamental ideas like variables, data types, operators, control flow, and functions, all through the lens of TypeScript. Even if you’re an experienced developer, a quick refresh can highlight nuances or best practices in TypeScript that you might have overlooked. For beginners, this will lay the essential groundwork for everything that follows.

By the end of this chapter, you’ll have a clear understanding of these foundational elements in TypeScript, setting you up for success as we tackle more complex topics. Let’s get started!

Core Concepts: The Building Blocks of Code

Every complex software system, from a simple mobile app to a global social network, is built upon a few fundamental programming concepts. Understanding these deeply is like knowing your alphabet before writing a novel.

Variables and Data Types: Holding Information

At its heart, programming is about working with data. Variables are like labeled containers that hold pieces of information in your program. Data types define what kind of information a variable can hold. TypeScript adds a fantastic layer of safety and clarity by allowing us to explicitly define these types.

Declaring Variables

In modern JavaScript and TypeScript, we primarily use let and const to declare variables.

let: Use this when you expect the variable’s value to change over time. It’s like a box where you can swap out its contents.
const: Use this when the variable’s value should never change after its initial assignment. It’s a box with a permanent label and content. Trying to reassign a const will result in an error, which is a good thing!

We generally avoid var in modern code due to its less intuitive scoping rules, which can lead to hard-to-find bugs. Stick with let and const.

Primitive Data Types

TypeScript supports all the standard JavaScript primitive types:

number: For any kind of number (integers, decimals).
string: For text.
boolean: For true or false values.
null: Represents the intentional absence of any object value.
undefined: Represents a variable that has been declared but not yet assigned a value.
symbol: For unique identifiers (less common in everyday code, but good to know).
bigint: For numbers larger than 2^53 - 1 (useful for very large numbers).

TypeScript also introduces the any type, which essentially opts out of type checking for that variable. While useful in some transitional scenarios, you should generally avoid any as it defeats the purpose of TypeScript’s type safety. We want to catch errors early!

Type Inference vs. Explicit Type Annotation

One of TypeScript’s superpowers is type inference. If you assign a value to a variable when you declare it, TypeScript is often smart enough to figure out its type automatically.

However, you can also use explicit type annotation to clearly state a variable’s type. This is especially useful when TypeScript can’t infer the type or when you want to make your code’s intent clearer.

Operators: Doing Things with Data

Operators are special symbols that perform operations on one or more values (operands) and return a result. They are the verbs of your programming language!

Arithmetic Operators: + (addition), - (subtraction), * (multiplication), / (division), % (modulo - remainder of division), ** (exponentiation).
Comparison Operators: == (loose equality), === (strict equality), != (loose inequality), !== (strict inequality), > (greater than), < (less than), >= (greater than or equal to), <= (less than or equal to).
- CRITICAL: Always prefer === and !==. The loose == and != operators perform type coercion, which can lead to unexpected behavior ('5' == 5 is true, but '5' === 5 is false). Strict equality checks both value and type.
Logical Operators: && (AND), || (OR), ! (NOT). These combine or negate boolean expressions.
Assignment Operators: = (assign), += (add and assign), -= (subtract and assign), *= (multiply and assign), /= (divide and assign), etc. These are shortcuts.
Ternary (Conditional) Operator: condition ? valueIfTrue : valueIfFalse. A concise way to write simple if/else statements.

Control Flow: Guiding Your Program’s Path

Control flow statements determine the order in which individual statements or instructions are executed. They allow your program to make decisions and repeat actions.

Conditional Statements

if/else if/else: Executes different blocks of code based on whether a condition is true or false.
switch: A more structured way to handle multiple possible execution paths based on the value of a single expression.

Looping Statements

Loops allow you to repeatedly execute a block of code. This is fundamental for processing collections of data, which we’ll do a lot in DSA!

for loop: Ideal when you know how many times you want to iterate (e.g., iterating through an array by index).
while loop: Continues as long as a specified condition is true. Use when the number of iterations isn’t known beforehand.
do...while loop: Similar to while, but guarantees the loop body executes at least once before the condition is checked.
for...of loop: A modern and clean way to iterate over iterable objects (like arrays, strings, Maps, Sets). It directly gives you the value of each element.
for...in loop: Iterates over the keys (property names) of an object. Generally less common for arrays due to potential issues with inherited properties and order.

Functions: Reusable Blocks of Code

Functions are self-contained blocks of code designed to perform a specific task. They are essential for organizing your code, promoting reusability, and making your programs easier to understand and debug.

Defining Functions

In TypeScript, you can define functions in several ways:

Named Functions: The classic way, giving the function a name.
Anonymous Functions: Functions without a name, often assigned to a variable or passed as arguments.
Arrow Functions: A concise syntax for anonymous functions, especially useful for short functions or when this context is important (we’ll touch on this later).

Parameters and Return Types

TypeScript shines here by allowing you to specify the types of function parameters and the type of the value the function returns. This helps catch errors before your code even runs!

Optional Parameters: Indicated by ? (e.g., (name?: string)).
Default Parameters: Provide a default value if an argument is not supplied (e.g., (message: string = "Hello")).

Basic Object-Oriented Concepts (in TypeScript)

While TypeScript isn’t a purely object-oriented language like Java, it provides excellent support for object-oriented programming (OOP) principles. For our foundations review, we’ll focus on basic objects and how TypeScript helps define their structure.

Objects: Collections of key-value pairs. Keys are strings (or Symbols), and values can be any data type, including other objects or functions.
Interfaces: TypeScript’s way to define the “shape” of an object. An interface specifies what properties and methods an object must have. This is incredibly powerful for ensuring consistency and correctness.
Classes: Blueprint for creating objects. They encapsulate data (properties) and functions (methods) that operate on that data. We’ll explore classes more deeply when we build data structures.

Step-by-Step Implementation: Getting Hands-On

Let’s put these concepts into practice! We’ll create a new TypeScript file and incrementally add code to illustrate everything we’ve discussed.

Create a New File: Inside your src directory (created in Chapter 2), create a new file named foundations.ts.
```
# From your project root
touch src/foundations.ts
```

Open src/foundations.ts and add the following code, step by step:

// Step 1: Variables and Data Types
console.log("--- Variables and Data Types ---");

// Type inference: TypeScript knows 'appName' is a string
let appName = "DSA Master Guide";
console.log(`Application Name: ${appName}`);

// Explicit type annotation: We tell TypeScript 'version' is a number
const version: number = 1.0;
console.log(`Version: ${version}`);

// Let's try to change a 'const' (this will cause a compile-time error if uncommented!)
// version = 1.1; // Error: Cannot assign to 'version' because it is a constant.

let isActive: boolean = true;
console.log(`Is Active: ${isActive}`);

let userCount: number; // Declared but not assigned, so it's 'undefined'
console.log(`User Count (before assignment): ${userCount}`);
userCount = 100;
console.log(`User Count (after assignment): ${userCount}`);

let favoriteColor: string | null = "blue"; // Union type: can be string or null
console.log(`Favorite Color: ${favoriteColor}`);
favoriteColor = null; // Valid!
console.log(`Favorite Color (after setting to null): ${favoriteColor}`);


// Step 2: Operators
console.log("\n--- Operators ---");

let num1: number = 10;
let num2: number = 3;

console.log(`Addition: ${num1 + num2}`);      // 13
console.log(`Subtraction: ${num1 - num2}`);   // 7
console.log(`Multiplication: ${num1 * num2}`); // 30
console.log(`Division: ${num1 / num2}`);      // 3.333...
console.log(`Modulo (Remainder): ${num1 % num2}`); // 1 (10 divided by 3 is 3 with remainder 1)

// Comparison operators
console.log(`Is ${num1} strictly equal to ${num2}? ${num1 === num2}`); // false
console.log(`Is ${num1} greater than ${num2}? ${num1 > num2}`);       // true

// Logical operators
let isAdult = true;
let hasLicense = false;
console.log(`Can drive (adult AND license)? ${isAdult && hasLicense}`); // false
console.log(`Can enter club (adult OR ticket)? ${isAdult || hasLicense}`); // true
console.log(`Not adult? ${!isAdult}`);                                  // false

// Ternary operator
let message = num1 > num2 ? "num1 is greater" : "num2 is greater or equal";
console.log(`Ternary message: ${message}`);


// Step 3: Control Flow - Conditionals
console.log("\n--- Control Flow: Conditionals ---");

let temperature = 25;

if (temperature > 30) {
    console.log("It's hot outside!");
} else if (temperature >= 20) {
    console.log("It's a pleasant day.");
} else {
    console.log("It's a bit chilly.");
}

let dayOfWeek = "Wednesday";
switch (dayOfWeek) {
    case "Monday":
    case "Tuesday":
    case "Wednesday":
        console.log("It's a weekday.");
        break;
    case "Saturday":
    case "Sunday":
        console.log("It's the weekend!");
        break;
    default:
        console.log("That's not a valid day.");
}


// Step 4: Control Flow - Loops
console.log("\n--- Control Flow: Loops ---");

console.log("For loop (counting up to 3):");
for (let i = 0; i < 3; i++) {
    console.log(`Count: ${i}`);
}

console.log("While loop (counting down from 3):");
let count = 3;
while (count > 0) {
    console.log(`Count: ${count}`);
    count--;
}

console.log("For...of loop (iterating over an array):");
const fruits: string[] = ["apple", "banana", "cherry"];
for (const fruit of fruits) {
    console.log(`Fruit: ${fruit}`);
}


// Step 5: Functions
console.log("\n--- Functions ---");

// Named function with type annotations
function greet(name: string, greeting: string = "Hello"): string {
    return `${greeting}, ${name}!`;
}
console.log(greet("Alice")); // Uses default greeting
console.log(greet("Bob", "Hi"));

// Arrow function
const add = (a: number, b: number): number => {
    return a + b;
};
console.log(`Sum of 5 and 7: ${add(5, 7)}`);


// Step 6: Basic Object and Interface
console.log("\n--- Basic Object and Interface ---");

// Define an interface for a 'Person'
interface Person {
    name: string;
    age: number;
    isStudent?: boolean; // Optional property
}

// Create an object that adheres to the 'Person' interface
const user: Person = {
    name: "Charlie",
    age: 30,
    isStudent: false
};

console.log(`User Name: ${user.name}`);
console.log(`User Age: ${user.age}`);

// You can omit optional properties
const anotherUser: Person = {
    name: "Diana",
    age: 22
};
console.log(`Another User Name: ${anotherUser.name}`);
console.log(`Is Another User a Student? ${anotherUser.isStudent ?? "Not specified"}`); // Using nullish coalescing for clarity

Compile and Run: Open your terminal in the project root and run:
```
npx ts-node src/foundations.ts
```
You should see the output of each section printed to your console. This confirms your TypeScript environment is working and you’ve successfully applied these foundational concepts!

Mini-Challenge: Sum of Even Numbers

It’s your turn to code! This challenge will reinforce your understanding of functions, loops, conditionals, and basic arithmetic.

Challenge: Write a TypeScript function named sumEvenNumbers that takes an array of numbers as input. The function should iterate through the array and return the sum of all the even numbers within it.
For example, sumEvenNumbers([1, 2, 3, 4, 5, 6]) should return 12 (2 + 4 + 6).
Hint:
- You’ll need a for loop (or for...of).
- An if statement will help you check if a number is even.
- The modulo operator (%) is perfect for determining if a number is even (a number n is even if n % 2 === 0).
- Remember to declare a variable to keep track of the running sum!
What to observe/learn: This exercise combines several foundational concepts. Pay attention to how you declare the function, type its parameters and return value, and integrate looping and conditional logic to solve a specific problem. This pattern of iterating and checking conditions is very common in Data Structures and Algorithms!

(Take a moment to try solving it before peeking at a potential solution or moving on!)

Common Pitfalls & Troubleshooting

Even with foundational concepts, a few common mistakes can trip up new (and even experienced) developers.

Type Mismatches (TypeScript’s Guardian Angel):
- Pitfall: Trying to assign a value of one type to a variable declared with another type (e.g., let age: number = "twenty";).
- Troubleshooting: TypeScript will usually catch this before you even run your code, giving you a clear error message. Read the error carefully! It will tell you which types are incompatible. Embrace these errors – they are TypeScript’s way of protecting you from bugs.
- Solution: Ensure the value you assign matches the variable’s declared type. If a variable can hold multiple types, use a union type like string | number.
Loose vs. Strict Equality (== vs ===):
- Pitfall: Using == instead of === can lead to subtle bugs because == performs type coercion. For example, 0 == false is true, and '5' == 5 is true.
- Troubleshooting: If a conditional statement isn’t behaving as expected, double-check your comparison operators.
- Solution: As a best practice, always use === (strict equality) and !== (strict inequality) unless you have a very specific, well-understood reason not to. This eliminates unexpected type coercion.
Off-by-One Errors in Loops:
- Pitfall: A classic! This happens when your loop condition or starting/ending index is slightly off, causing the loop to run one too many or one too few times. For example, for (let i = 0; i <= array.length; i++) will try to access array[array.length], which is undefined.
- Troubleshooting: When debugging loops, use console.log() inside the loop to print the loop counter (i) and the value being accessed (array[i]). Step through your code mentally or with a debugger.
- Solution: For iterating through arrays by index, remember that arrays are 0-indexed, so a common pattern is for (let i = 0; i < array.length; i++). This ensures you iterate from the first element (index 0) up to, but not including, the length, which is the last valid index.

Summary

Phew! You’ve just completed a rapid but thorough refresh of programming fundamentals in TypeScript. Here are the key takeaways:

Variables: Use let for mutable data, const for immutable data.
Data Types: TypeScript provides types like number, string, boolean, null, undefined, and allows explicit type annotation or inference. Avoid any!
Operators: Understand arithmetic, comparison (prefer ===), logical, and assignment operators.
Control Flow: Master if/else, switch, and various loops (for, while, for...of) to guide your program’s execution.
Functions: Organize reusable code, leveraging TypeScript’s type annotations for parameters and return values.
Interfaces: Use them to define the expected shape of your objects, enhancing code clarity and preventing errors.

With these foundational concepts firmly in place, you’re now perfectly poised to tackle the exciting world of Data Structures and Algorithms. These basics are the bedrock upon which all complex algorithms are built.

In our next chapter, we’ll introduce a critical concept for understanding and comparing algorithms: Complexity Analysis and Big-O Notation. Get ready to learn how to evaluate the efficiency of your code!

References

This page is AI-assisted and reviewed. It references official documentation and recognized resources where relevant.