📘 Variables & Types: Programming Foundations

What you’ll learn

1. What Is a Variable, Really?Define a variable as a named binding between an identifier and a value stored in memory, and distinguish the name, the value, and the location.A variable is not a box that holds a value; it is a name bound to a value, and that binding is the central act of programming. The same identifier can be rebound to different values over time, while the value itself lives somewhere in memory and may be shared by several names. Separating the three ideas of name, binding, and value prevents an entire class of beginner confusion. This vocabulary carries directly into how we reason about types, assignment, and references in every later lesson.
2. Types Give Values MeaningExplain that a data type defines a set of possible values together with the operations valid on them, and identify the core primitive types.A type is a contract: it fixes the set of values a piece of data can take and the operations that are legal on it. The same bits in memory can mean an integer, a character, or part of a floating-point number depending solely on the type that interprets them. The Python data model captures this by stating that an object's type determines the operations it supports and the values it can hold. Knowing the core families of types lets you predict what a value can and cannot do before you ever run the code.
3. How Numbers Live in MemoryDescribe how integers are stored using two's complement and why floating-point numbers are approximate, including the consequences for arithmetic.Integers are commonly stored in fixed-width two's complement, which gives a single representation of zero and a range of negative two to the n-minus-one through positive two to the n-minus-one minus one for n bits. Floating-point numbers follow the IEEE 754 binary64 format, packing a sign, an 11-bit exponent, and a 52-bit fraction into 64 bits, which yields about 15 to 17 significant decimal digits but cannot represent most decimal fractions exactly. This is why 0.1 + 0.2 does not equal 0.3 in standard floating-point arithmetic, and why fixed-width integers can overflow. Understanding these representations turns mysterious bugs into predictable behavior.
4. Static and Dynamic TypingContrast static and dynamic typing by when type information is bound and checked, and distinguish that axis from strong versus weak typing.Static typing binds a variable to a type at compile time and checks type rules before the program runs, while dynamic typing associates types with values at runtime and checks them as the program executes. A separate axis, strong versus weak typing, describes how strictly a language forbids mixing incompatible types without explicit conversion. These two axes are independent: Python is dynamically and strongly typed, while C is statically but comparatively weakly typed. Knowing where a language sits explains when its type errors appear and how much implicit coercion to expect.
5. Conversion, Coercion, and Common PitfallsDifferentiate explicit type conversion from implicit coercion and diagnose the classic bugs each can cause.Type conversion changes a value from one type to another; it is explicit when the programmer requests it and implicit, called coercion, when the language performs it automatically. Coercion is convenient but can hide bugs, such as 'number plus string' producing unexpected concatenation, or a narrowing conversion silently losing precision. Comparing floating-point values for exact equality is a related classic mistake, fixed by comparing within a tolerance. Recognizing which conversions are lossless and which are lossy, and preferring explicit conversion at boundaries, is a hallmark of careful code.
6. Build It: A Typed Mini-ArtifactApply variables, types, conversion, and float-safe comparison by building and reasoning about a small program artifact for your portfolio.This capstone lesson guides you to build a small, well-typed program, such as a tip-and-split calculator, that exercises every concept from the course. You will declare clearly named variables, convert string input to numbers explicitly, perform arithmetic across integer and floating-point types, and compare floats safely with a tolerance. You will also annotate your code with the type of each key value and write a short reflection identifying where conversion and rounding mattered. The finished program plus its annotations and reflection form the portfolio artifact that demonstrates your command of variables and types.

Questions this course answers

Grounded in trusted sources

• Python docs, Data model / built-in types, https://docs.python.org/3/library/stdtypes.html
• MDN, JavaScript data types and variables, https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures
• Java Tutorials, Primitive Data Types, https://docs.oracle.com/javase/tutorial/java/nutsandbolts/datatypes.html
• CS50, Variables and types lecture materials, https://cs50.harvard.edu/

Every Wunder lesson is built from real, reputable sources — never invented.

Related courses