Variables and Data Types

Imagine your RAM is a large cabinet with thousands of drawers. A variable is one of those drawers with a label on the front. When you create the variable 'age' and store the value 25, you are telling the computer: 'reserve a drawer, call it age, and put 25 inside it'.

The great advantage of using variables instead of fixed values is flexibility. If you calculate income tax using the literal value 25 scattered throughout the code, you will have to change every occurrence when the age changes. With a variable, you only need to change it in one place.

Declaring a variable is the act of creating it and reserving memory space. Assigning is the act of putting a value inside it. In many languages, these two acts happen together: 'int age = 25' declares the variable 'age' of type integer and immediately assigns the value 25.

The data type defines what category of information a variable can hold and what operations can be performed on it. The four fundamental types are: integer (numbers without decimal places), floating point (numbers with decimal places), string (text), and boolean (true or false).

Integers are used for counts, indices, and discrete quantities: number of students, position in a list, result of integer division. Floats (floating point) are used when decimal precision matters: prices, measurements, scientific results.

Strings store sequences of characters: names, addresses, messages. The boolean, with only two possible values (true or false), seems simple but is the most powerful type in logic: every conditional structure and loop depends on a boolean expression.

A classic mistake for beginners is mixing types without realizing it. In many languages, '5' (string) + 5 (integer) does not result in 10. In Python, for example, this raises a TypeError. In JavaScript, it results in '55' (text concatenation). The same '+' symbol behaves completely differently depending on the types involved.

This behavior exists because the computer does not know your intention. Do you want to add mathematically or join text? By specifying the correct type, you eliminate this ambiguity. This careful handling of types is called typing — languages like Java and C are strongly typed (requiring explicit declaration), while Python and JavaScript are more flexible but still sensitive to type conflicts.

Not every value needs to change during program execution. The number pi (3.14159...) does not change; the speed of light does not change; the tax rate for a fiscal period does not change. For these cases, we use constants.

A constant is like a variable that, once defined, cannot be reassigned. Declaring a value as a constant communicates intent to the programmer reading the code in the future: 'this value must not be changed'. Many languages have specific keywords for this, such as 'const' in JavaScript or 'final' in Java.

A good variable name is self-explanatory. 'x' says nothing; 'totalMonthlySales' is immediately understandable. This may seem obvious, but it makes an enormous difference when you revisit code written six months ago — or when another programmer needs to understand it.

The most common conventions are camelCase (totalSales), snake_case (total_sales), and PascalCase (TotalSales). The choice depends on the language and the team. What matters is consistency: mixing conventions in the same project makes reading and maintenance harder.

Avoid obscure abbreviations, single-letter names (except loop counters like 'i' and 'j'), and names that conflict with reserved words of the language.