Hi Bruno,

Great question. Both NOT and <> / != can be used to exclude values, but there are cases where NOT is preferred for clarity.

Here’s when using NOT can make more sense:

1. With complex conditions
   When you're excluding entire conditions or expressions, NOT can make things clearer:

   WHERE NOT (age < 18 OR country = 'UAE')
   

2. With subqueries
   NOT IN and NOT EXISTS are common and often easier to read than alternatives:

   WHERE NOT EXISTS (SELECT * FROM ...)
   

3. Improved readability
   In some cases, AND NOT country = 'UAE' might be easier to read than country != 'UAE', especially in long conditions.

That said, if you're just comparing single values, <> or != is shorter and works just as well:

WHERE country != 'UAE'

In the end, it comes down to readability and personal or team preference. Functionally, both work — pick the one that makes your intent clearest.

If you’ve got more questions, I’m here to help.

Hi Soumyadeep,

Yes, it’s easier than it seems! Let’s take a simple example using the OR operator (||), which is one kind of logical gate.

The OR operator checks two conditions and gives true if at least one of them is true.

Here’s how it works in code:

if ((age >= 18) || (gpa > 3.5)) {
    printf("You meet the criteria.\n");
}

This line means:
“If the person is 18 or older, or their GPA is above 3.5, then print the message.”

Examples:

• If age is 20 and GPA is 3.0 → it prints (because age ≥ 18)

• If age is 16 and GPA is 3.8 → it prints (because GPA > 3.5)

• If age is 16 and GPA is 3.0 → it doesn’t print (because both are false)

So in simple terms:
OR means only one condition needs to be true for the code to run.

Let me know if you want help understanding other gates like AND or NOT — I’m here to help.

Hi Gowtham,

Good question! Let’s break it down simply.

A bit is the smallest unit of data in a computer. It's either a 0 or a 1.

But in practice, we usually deal with bytes, and 1 byte = 8 bits.

So when we talk about how many bits something uses, we’re really asking how much space it takes in memory. For example:

• char = 1 byte = 8 bits

• int = 4 bytes = 32 bits

• double = 8 bytes = 64 bits

You can check this in C++ using the sizeof operator:

#include 
using namespace std;

int main() {
    cout << "char: " << sizeof(char) << " byte" << endl;
    cout << "int: " << sizeof(int) << " bytes" << endl;
    cout << "double: " << sizeof(double) << " bytes" << endl;
    return 0;
}

The output tells you how many bytes each type uses. Just multiply that by 8 to get the number of bits.

So bits are calculated based on the data type and how much space it uses in memory.

If you’d like help with binary values or how bits are used in operations, I’m here to help.

Hi Shawn,

The main difference is in how they’re defined:

• List → uses square brackets []

  my_list = [1, 2, 3]
  

• Tuple → uses parentheses ()

  my_tuple = (1, 2, 3)
  

If you're creating a tuple with just one item, you need a comma — otherwise, Python won’t treat it as a tuple:

single_item = (1)     # This is just the number 1  
single_item_tuple = (1,)  # This is a tuple with one item

Lists don’t need a comma for single items, and you can freely change (mutate) them — unlike tuples, which are immutable.

If you have more questions, I am here to help.

Hi Amogh,

In Python, the not keyword is a logical operator that flips the value of a condition:

• not True becomes False

• not False becomes True

So when you use if not, you're checking if a condition is not true.

Here’s a simple example:

is_raining = True

if not is_raining:
    print("You don't need to bring an umbrella")
else:
    print("Please bring an umbrella")

In this case, is_raining is True, so not is_raining becomes False, and the code inside the else block runs.

In short, if not is used when you want to run code only when a condition is false.

If you have more questions, I am here to help.

Hi Timi,

Good question. It depends on how the function is defined.

Here’s your example:

def greet(message):
    print(message)

greet('Hi', 'Hello')

In this case, the function greet is defined to accept only one argument — message. But when you call it with two arguments ('Hi', 'Hello'), Python throws an error:

TypeError: greet() takes 1 positional argument but 2 were given

So actually, it doesn’t return one output — it raises an error because you passed more arguments than expected.

If you want the function to handle multiple messages, you can use *args, like this:

def greet(*messages):
    for message in messages:
        print(message)

greet('Hi', 'Hello')

Output:

Hi  
Hello

Using *messages lets the function accept any number of arguments and print each one.

If you have more questions, I am here to help.

Hi Ian,

Good question. You don’t need to declare the first number as 1. Instead, you can use a loop that runs 5 times and asks the user to enter a number each time. You just keep adding each input to a running total.

Here’s how you can do it in C++:

#include 
using namespace std;

int main() {
    int sum = 0;    // to store the total
    int number;     // to hold each number entered by the user

    for (int i = 1; i <= 5; i++) {
        cout << "Enter number " << i << ": ";
        cin >> number;
        sum += number;  // add the number to the total
    }

    cout << "Total sum is: " << sum << endl;
    return 0;
}

How it works:

• You start with sum = 0 — the total will build up as users enter numbers.

• A for loop runs 5 times (from 1 to 5).

• In each iteration, the user enters a number, and it’s added to sum.

So, no need to start by declaring a number as 1. The loop and input take care of that.

If you have more questions, I am here to help.

Hi Isabella,

You’re absolutely right — range-based for loops are a great way to simplify your code. But in your case, the reason it doesn’t work likely has to do with how arrays behave when passed to functions in C++.

Here's the issue:

When you pass an array like this:

void find_average(double elements[5]) { ... }

Inside the function, elements is actually treated as a pointer (double*), not a real array. The compiler loses the size information, which the range-based for loop depends on to work.

So this:

for (double number : elements)

won’t work because C++ doesn’t know how many elements to loop over.

✅ How to fix it

Option 1: Use a loop with an explicit size

void find_average(double* elements, int size) {
    double sum = 0.0;
    for (int i = 0; i < size; ++i) {
        sum += elements[i];
    }
}

Option 2: Use std::array or std::vector
These keep size information, so range-based loops work fine:

#include 

void find_average(const std::array& elements) {
    double sum = 0.0;
    for (double number : elements) {
        sum += number;
    }
}

So yes — range-based for loops do the same thing, but they only work when the size of the container is known. With plain arrays in functions, that size gets lost.

If you have more questions, I am here to help.

Hi Kamohelo,

That error usually means you're trying to update something that doesn't exist in the DOM at the moment you're accessing it. In this case, you're trying to set the textContent of an element, but the variable holding that element is actually undefined.

This often happens when you're using something like element.children[2], but there are fewer than 3 children, so JavaScript can't find the item at index 2. Then, when you try to set textContent, it throws the error because you’re basically saying undefined.textContent = ..., which isn't valid.

Let’s say your code looks like this:

const priceList = document.querySelector("#price-list");
const update = document.querySelector("#update");

update.addEventListener("click", () => {
    const thirdItem = priceList.children[2];
    const thirdItemPrice = thirdItem.children[0];
    thirdItemPrice.textContent = "$4.00";
});

If thirdItem doesn’t exist, or if it doesn’t have a child at index 0, you’ll get that exact error.

To avoid it, you can add checks:

if (thirdItem && thirdItem.children.length > 0) {
    const thirdItemPrice = thirdItem.children[0];
    if (thirdItemPrice) {
        thirdItemPrice.textContent = "$4.00";
    } else {
        console.error("The child element you're trying to access doesn't exist.");
    }
} else {
    console.error("The third list item or its children do not exist.");
}

Also, using console.log() is super helpful — it lets you see what each variable actually holds before using it. That way, you can catch undefined values early and avoid these errors.

If you have more questions, I am here to help.

Hi Tom,

Yes, exactly — WHERE always comes before GROUP BY in SQL.

Here’s why: the WHERE clause filters the rows before any grouping happens. So only the rows that match your condition are included in the groups.

Let’s say you have this query:

SELECT department, MIN(age) AS min_age, MAX(age) AS max_age
FROM Employees
WHERE department <> 'Marketing'
GROUP BY department;

First, SQL filters out all rows where the department is 'Marketing'. Then it groups the remaining rows by department and calculates the min and max age for each group.

If you applied the WHERE after GROUP BY, it wouldn’t work — because WHERE doesn’t operate on groups. That’s what HAVING is for, if you ever need to filter after grouping.

So yes, WHERE always comes first.

If you have more questions, I am here to help.