In our previous article, you learned how to think like a programmer. You discovered that programming is about breaking down problems, finding patterns, and building solutions step by step. The thinking part comes before the typing part.
Now here’s something that confused the hell out of me when I started: why computers care so much about labels.
Your brain is amazing at figuring out context. If I write “25” in my notes, my brain automatically knows if that’s someone’s age, how much money I owe someone, or how many people showed up to something. I don’t need to write “age: 25” or “money: 25″—context does the work.
Computers don’t have that superpower. They’re incredibly fast at following instructions, but they’re also incredibly dumb about understanding what things mean. They need you to tell them exactly what kind of information you’re handing them.
That’s what data types are about, and honestly, once you understand why they exist, everything else in programming makes way more sense.
What We’re Covering Today
- Why computers need us to categorize information
- The handful of basic types that show up everywhere
- How to group simple data into useful collections
- Why organizing data correctly saves hours of debugging later
- Hands-on activities using AI to practice what you’re learning
Let’s dig in.
What is Data?
Data is just information. The number 42. Your name. Whether you’ve eaten lunch yet. All of these are data—just facts sitting there.
But here’s the thing: you wouldn’t store your laptop the same way you store your shoes, right? Your laptop needs a safe spot where it won’t get crushed or wet. Your shoes go wherever—maybe under your bed, maybe by the door. Both are storage, but completely different strategies because the items need different care.
Computers work exactly like this. They need to know what kind of information you’re giving them so they can store it right and do the appropriate things with it. Try to add the letter ‘A’ to the number 5 and the computer has no idea what you’re asking for. But tell it you’re adding numbers, and suddenly it knows exactly what to do.
Let’s look at the types that actually matter.
The Basic Types: Five Categories That Run Everything
Think of these like ingredients. Flour, eggs, sugar, butter—you can’t break them down further, but you can combine them into basically anything.
Yes or No: The Decision Type
Sometimes you just need an answer. Is it raining? Did you finish your homework? Are you logged into Netflix?
In programming, this is called a Boolean. Ignore the name (it’s named after some dead mathematician, not important). What matters is it’s either true or false. That’s it. Two options.
Real examples:
- Is the door locked? true
- Did you pass the quiz? false
- Is the WiFi working? true
Why it exists: Every decision a computer makes comes down to checking if something is true or false. Every “if this, then that” in a program is testing a true/false value. You’ll use these constantly.
Whole Numbers: The Counting Type
When you count things, you use whole numbers. How many notifications do you have? 47. How many pesos in your wallet? 250. Your age? 17.
These are integers—just a fancy word for whole numbers. No decimals, no fractions, just complete numbers.
Real examples:
- Unread messages: 12
- Level in a game: 8
- Number of followers: 2,459
Why it exists: Computers count things the same way you do. How many items in a list? What position is this song in your playlist? You need whole numbers for that. You can’t be on level 7.3 of a game.
Decimal Numbers: The Precision Type
Sometimes you need exact measurements. A price: ₱149.75. Your average grade: 88.5. Today’s temperature: 32.6°C.
These are floating-point numbers, usually just called floats. The decimal point can “float” around to different positions, which is why they have that weird name.
Real examples:
- Cost of something: ₱1,299.99
- Your grade point average: 87.3
- Distance traveled: 15.7 km
Why it exists: Money, measurements, grades—anything where precision matters needs decimals. If you stored ₱149.75 as an integer, you’d lose the 75 centavos. That adds up.
Single Letters: The Character Type
One letter, number, or symbol by itself is a character. Just one. The letter ‘M’. The number ‘7’. A question mark ‘?’.
Real examples:
- First initial: ‘J’
- A grade: ‘B’
- A symbol: ‘@’
Why it exists: Most of the time you work with full words, but sometimes you need to check individual letters—like seeing if someone’s last name starts with ‘S’ or checking if a password has a special character.
Text: The Words Type
Words, sentences, messages, anything you’d read or type. Your name. A tweet. A text message. A Google search.
This is a string—imagine letters on a string, all connected. That’s where the name comes from.
Real examples:
- Your name: “Maria Santos”
- A text: “Hey, what time are you coming over?”
- A search: “best anime 2024”
Why it exists: Everything you read on a screen is a string. Every button label, every message, every piece of text. You can’t build anything without strings.
ACTIVITY 1: Type Detective
Try this with ChatGPT, Claude, or any AI assistant:
Copy and paste this prompt:
I'm learning about data types in programming.
I'll give you some pieces of information.
You help me figure out what data type each one should be.
For each item, tell me if it should be:
Boolean (true/false)
Integer (whole number)
Float (decimal number)
Character (single letter/symbol)
String (text)
Here are my items:
1. A person's full name
2. Whether someone is online
3. The number of likes on a post
4. The price of a shirt
5. Someone's middle initial
6. A tweet message
7. Your current level in a game
8. Whether a file finished downloading
9. The distance to school in kilometers
10. A password
After you tell me the types, give me 5 NEW examples and let me guess.
Then check my answers and explain why I got any wrong.What you’ll learn: How to identify which type fits different kinds of information. The AI will give you immediate feedback and help you spot patterns.
ACTIVITY 2: The Wrong Type Challenge
Try this with your AI assistant:
Let's explore what happens when you use the wrong data type.
I'll describe a situation where someone chose the wrong type.
You explain what would go wrong.
Situation 1:
Someone stored ages as text (string) instead of integers.
What problems would happen when they try to:
- Find the oldest person in a list
- Calculate average age
- Check if someone is old enough to vote (18+)
Situation 2:
Someone stored prices as integers instead of floats.
What gets messed up?
Situation 3:
Someone stored phone numbers as integers instead of text.
What breaks?
After explaining these, give me 3 more "wrong type" scenarios.
Let me figure out what would break. Check my reasoning.What you’ll learn: Why choosing the correct type isn’t just technical pickiness—it actually affects what your program can do.
Building Useful Things From Simple Pieces
Alright, basic types are cool, but real life is messier. A person isn’t just a name—they’ve got an age, an email, a birthday, an address. A song isn’t just a title—it has an artist, duration, genre.
This is where programming gets practical.
Grouping Different Info Together: The Profile Type
Say you’re making a student profile for a school portal. You need:
- Name (text)
- Age (whole number)
- Grade average (decimal number)
- Currently enrolled? (yes/no)
These are different types, but they all describe one student. You group them into what’s called a record or object. Think of it like your student ID card—one card with multiple pieces of info on it.
One student’s complete info:
- Name: “Carlos Rivera”
- Age: 16
- Grade average: 89.7
- Currently enrolled: true
Why it exists: Real-world things have multiple properties. Your phone has a brand, price, color, storage size. Your favorite YouTuber has a name, subscriber count, upload schedule. Keeping related info together makes everything easier to manage.
Making Lists of Similar Things: The Collection Type
Now imagine you need all the students in your entire class. You could make variables like Student1, Student2, Student3… but that’s insane.
Instead, you make a list—an array. Just an ordered list of items that are all the same type.
Examples:
- Student names: [“Ana”, “Carlos”, “Maria”, “Jose”, “Luis”]
- Test scores: [85, 92, 78, 88, 95]
- Your Spotify playlist: [“Song 1”, “Song 2”, “Song 3”]
Why it exists: Almost everything involves lists. Your Instagram feed is a list. Your notifications are a list. Search results are a list. Once you have a list, you can go through it item by item, sort it however you want, search it, filter it.
Enter JSON: The Universal Way to Store and Share Data
So now you know about objects (records) and arrays (lists). But how do we actually write them down in a way that computers—and even people—can easily read and share?
That’s where JSON comes in.
JSON stands for JavaScript Object Notation. Don’t let the name scare you—it’s just a simple text format for representing data. Think of it as a way to write down objects and arrays so they can be saved in a file, sent over the internet, or shared between apps.
How JSON Looks
Let’s take the student profile example and write it in JSON:
{
"name": "Carlos Rivera",
"age": 16,
"gradeAverage": 89.7,
"currentlyEnrolled": true
}
- Curly braces
{ }mean object (a record with properties). - Each property has a key (like
"name") and a value (like"Carlos Rivera"). - Keys are always in quotes, values can be text, numbers, decimals, true/false, or even other objects/arrays.
JSON Arrays
Now let’s say we want a list of students. That’s an array in JSON:
[
"Ana",
"Carlos",
"Maria",
"Jose",
"Luis"
]
And if we want a list of student profiles (objects inside an array):
[
{
"name": "Ana Lopez",
"age": 15,
"gradeAverage": 91.2,
"currentlyEnrolled": true
},
{
"name": "Carlos Rivera",
"age": 16,
"gradeAverage": 89.7,
"currentlyEnrolled": true
},
{
"name": "Maria Santos",
"age": 17,
"gradeAverage": 94.5,
"currentlyEnrolled": false
}
]
Why JSON is Super Useful
- Universal language: Almost every programming language understands JSON.
- Easy to share: Apps, websites, and servers use it to send data back and forth.
- Human-readable: You can open a JSON file and actually understand what’s inside.
- Flexible: You can mix objects and arrays to represent almost anything—profiles, playlists, shopping carts, game stats.
ACTIVITY 3: Design Your Own Data Structure
Try this with your AI:
Create one music track profile with these fields:
- Title (text)
- Artist (text)
- DurationSeconds (whole number)
- Favorite (yes/no)
1. Show the track profile neatly.
2. Explain why each field uses that data type.
3. Then immediately expand into an array (list) of 3 music track profiles.
Use the same fields.
4. Explain what an array is and why it uses square brackets.
Explain also why arrays are useful.
After your explanation, ask me to:
- Create one contact profile
- Then create an array of 3 contact profiles using those fields.
When I respond, check my work for:
- Consistent fields
- Realistic values
- Correct data types
- Anything I might be missingWhat you’ll learn: How to think through what data you need before building anything. This is exactly what professional developers do in the planning phase.
How Programmers Plan Before Building
Before building anything—a grade tracker, a game, a social media clone—you plan what info you’ll need.
Professional programmers make a data dictionary. It’s just a chart that says “here’s what we’re tracking and what type each thing is.”
Simple example for tracking students:
| Information | Type | Required? | Example |
|---|---|---|---|
| Full name | Text | Yes | “Maria Santos” |
| Age | Whole number | Yes | 17 |
| Grade average | Decimal number | Yes | 87.5 |
| Enrolled status | Yes/No | Yes | true |
| Home address | Text | Optional | “123 Main St” |
The “Required?” column matters. Some info is essential (name, age), some is optional (address).
Why do this? Because building without planning is like packing for a trip without checking what you need. You’ll forget stuff and have to start over. Same thing here—plan first, build second, save yourself hours of frustration.
ACTIVITY 4: Build Your Data Dictionary
Try this with your AI:
I want to practice making a data dictionary.
Let’s pick something simple from my daily life.
It can be my favorite snacks, my weekly allowance, or my school schedule.
Please ask me questions to help me decide what information I should track.
Then, help me fill out a small data dictionary with at least 3–5 items.
If I forget something important, remind me.
If I choose the wrong data type, explain why and suggest a better one.What you’ll learn: The planning process that prevents you from building things wrong and having to start over. Every professional project starts with this.
How Different Info Connects
Here’s where real systems get interesting.
Say you’re building a grade tracker. You’ve got students, and you’ve got assignments. One student can have tons of assignments, right? Maria has Math homework, English essay, Science project, History report.
You need a way to say “these assignments belong to Maria.”
You do that by giving each student a unique ID number (like Student_12345). Then whenever you create an assignment, you tag it with Maria’s ID. Now you can pull up all her assignments just by looking for her ID.
This is called creating a relationship between information. The concept is simple: some information naturally links to other information, so you plan those links ahead of time.
Think of it like tagging photos on Instagram. The photo exists on its own, but you tag people to connect that photo to specific accounts. Same idea here—you’re creating connections between related data.
ACTIVITY 5: Map Out the Connections
Try this with your AI:
Help me practice connecting information like in the grade tracker example.
Give me a simple scenario with two types of things.
Students and assignments, or players and teams, or teachers and classes.
Ask me to figure out which things belong to which.
Also ask me how we could tag them with IDs.
After I answer, check my work and explain if I got the connections right.What you’ll learn: How professional apps organize information and why everything needs to connect properly. This is database thinking, and it’s everywhere.
Practice Time With Real Scenarios
Let’s make this concrete. What types would you use here?
Scenario 1: Making a contacts app
- Name: text
- Phone number: text (wait, why not a number? because you don’t do math with it, and it has symbols like +63)
- Favorite contact: yes/no
- Times contacted: whole number
Scenario 2: Tracking grades
- Subject: text
- Current grade: decimal number
- Passing: yes/no
- Absences: whole number
Scenario 3: Building a quiz game
- Question: text
- Correct answer: text
- Your answer: text
- Got it right: yes/no
- Total score: whole number
See the pattern? Think about what you need and how you’ll use it, and the right type becomes obvious.
ACTIVITY 6: Type Decisions in Real Scenarios
Final challenge with your AI:
I want to practice everything I learned about data types and structures.
Please guide me step by step, checking my answers as I go.
Pick a scenario
Give me 2–3 simple scenarios.
It can be “contacts app,” “grade tracker,” or “quiz game”.
I’ll choose one.
Choose fields and types
For my chosen scenario, list 3–4 pieces of information.
I’ll decide if each should be:
- Boolean (Yes/No)
- Integer (Whole number)
- Float (Decimal number)
- Character (Single letter/symbol)
- String (Text)
After I answer, check my work, and explain my mistakes.
Also, suggest one extra field.
Make a profile (record/object)
Help me combine those fields into a single profile with example values.
Expand into a list (array)
Show me how the same profile looks as an array of 3 examples.
Remind me why arrays are useful.
Write it in JSON
Convert the profile and the array into JSON format.
Check that my data types match correctly.
Interactive Data Dictionary
Draft a starter data dictionary table with columns:
- Information
- Type
- Required?
- Example
Leave the Type column blank for me to fill in.
Ask me to choose the type for each field.
Update the table as I answer, correcting mistakes and explaining why.
Suggest one extra field I might add, and ask if I want to include it.
Present the final completed data dictionary neatly formatted.
Connect related info
Suggest a second related thing (like students ↔ assignments).
I’ll describe how to link them with IDs.
Check if my connection makes sense.
Wrap up
Summarize my design.
Suggest one improvement I could make.What you’ll learn: How to apply everything you’ve learned to real situations. This is as close as you can get to actual programming without writing code yet.
Why Any of This Matters
I get it. This feels like unnecessary complexity just to store some info. But choosing the right types isn’t about being difficult—it’s about:
Preventing dumb mistakes
Store age as text? You might try adding “17” + “5” and get “175” instead of 22. The computer thinks you’re joining words, not doing math.
Saving memory
A whole number takes less space than a decimal. When you’re dealing with millions of records, that difference is huge.
Making things searchable
Store everything as text? Sorting breaks. The computer would think “9” comes after “1000” because it’s comparing letters, not numbers.
Catching bugs early
If your program expects yes/no and you give it someone’s name, it warns you immediately instead of crashing mysteriously later.
Data types are like traffic lanes. Technically cars could drive anywhere, but lanes keep things organized and prevent crashes. Same concept.
What You’ve Actually Learned
So here’s what we covered: data types tell computers what kind of info they’re working with. You learned the basics—yes/no values, whole numbers, decimals, single characters, and text.
You learned that real information combines multiple types into records (like how a student profile has name, age, and grades together). When you need many items of the same type, you use lists.
You discovered why choosing types matters: prevents mistakes, saves memory, makes searches work, catches errors before they explode.
You practiced identifying types, understanding what breaks when you choose wrong, designing data structures, creating data dictionaries, mapping connections, and applying everything to real scenarios.
Most importantly, this isn’t about memorizing definitions. It’s about thinking through what information you need and how you’ll use it before you build anything.
The first time you accidentally store a number as text and can’t figure out why your math is broken, you’ll get why data types exist. Everyone goes through this. It’s fine. That’s actually how you learn.
Next time, we’ll talk about how programs communicate with users and the outside world. For now, just remember: computers are fast but literal, and data types help them understand what we’re asking them to do.
Keep those AI conversations going—the more you practice identifying and organizing data, the more natural it becomes.
Leave a Reply