Think Like a Programmer: Mastering Basic Logic and Programming

Every developer starts somewhere. Before you write a single line of code, you need to learn how to think like a programmer.

This isn’t about memorizing syntax. It’s about developing a structured approach to solving problems that you’ll use every single day of your career.

---

Computational Thinking

Programming is just problem solving with a computer. The four pillars of computational thinking are:

1. Decomposition

Break a big problem into smaller, manageable pieces.

Want to build a login system? Don’t tackle it all at once:

Login System
├── User enters email & password
├── Validate input (not empty, valid format)
├── Check credentials against database
├── If match → create session, redirect to dashboard
└── If no match → show error message

Each piece is simple. Together, they solve the big problem.

2. Pattern Recognition

Look for similarities between problems. If you’ve solved something similar before, reuse that approach.

# You wrote this for a shopping cart
def calculate_total(items):
    total = 0
    for item in items:
        total += item.price
    return total

# Same pattern works for grading students
def calculate_average(scores):
    total = 0
    for score in scores:
        total += score
    return total / len(scores)

The pattern: iterate over a collection and accumulate a value. Once you recognize it, you see it everywhere.

3. Abstraction

Focus on what matters, ignore what doesn’t. A map doesn’t show every tree on every street. It shows roads and landmarks. That’s abstraction.

When modeling a User for a login system:

What matters:    email, password, name
What doesn't:    favorite color, shoe size, zodiac sign

4. Algorithm Design

Write a step-by-step solution that anyone (or any computer) can follow.

---

Flowcharts

Flowcharts are a visual way to plan your logic before coding.

Basic Symbols

Symbol	Shape	Meaning
Start/End	Oval	Beginning or end of process
Process	Rectangle	An action or calculation
Decision	Diamond	Yes/No question
Arrow	Line	Flow direction

Example: Login Flow

    [Start]
       ↓
  [Enter credentials]
       ↓
  <Is email valid?> ──No──→ [Show error] → [Start]
       │ Yes
       ↓
  <Password correct?> ──No──→ [Show error] → [Start]
       │ Yes
       ↓
  [Create session]
       ↓
  [Redirect to dashboard]
       ↓
    [End]

Flowcharts force you to think through every path your program can take, including error cases.

---

Pseudocode

Pseudocode is plain English that describes your logic. No syntax rules, just clear steps.

PROGRAM: Calculate final grade

INPUT: quiz_score, midterm_score, final_score

SET quiz_weight = 0.25
SET midterm_weight = 0.35
SET final_weight = 0.40

SET weighted_quiz = quiz_score * quiz_weight
SET weighted_midterm = midterm_score * midterm_weight
SET weighted_final = final_score * final_weight

SET final_grade = weighted_quiz + weighted_midterm + weighted_final

IF final_grade >= 85 THEN
    DISPLAY "Grade A"
ELSE IF final_grade >= 75 THEN
    DISPLAY "Grade B"
ELSE IF final_grade >= 60 THEN
    DISPLAY "Grade C"
ELSE
    DISPLAY "Grade D"
END IF

Now translate this to any language. Here’s the same logic in Dart:

void main() {
  double quizScore = 90;
  double midtermScore = 78;
  double finalScore = 85;

  double finalGrade = (quizScore * 0.25) +
                      (midtermScore * 0.35) +
                      (finalScore * 0.40);

  if (finalGrade >= 85) {
    print('Grade A');
  } else if (finalGrade >= 75) {
    print('Grade B');
  } else if (finalGrade >= 60) {
    print('Grade C');
  } else {
    print('Grade D');
  }
}

---

Variables & Data Types

A variable is a named container that stores data. Think of it like a labeled box.

Data Types

Type	What It Stores	Example
Integer	Whole numbers	42, -7, 0
Float/Double	Decimal numbers	3.14, -0.5
String	Text	"Hello", "dart"
Boolean	True or False	true, false
Array/List	Collection of items	[1, 2, 3]

Variable Naming Rules

Good names make code readable:

// Bad
var x = 25;
var temp = "Abdu";
var flag = true;

// Good
var age = 25;
var userName = "Abdu";
var isLoggedIn = true;

Rules of thumb:

• Use camelCase (userName, isLoggedIn)
• Names should describe the data
• Avoid single letters (except loop counters like i)
• Be consistent throughout your codebase

---

Operators

Arithmetic

int a = 10, b = 3;

a + b   // 13  (addition)
a - b   // 7   (subtraction)
a * b   // 30  (multiplication)
a / b   // 3.33 (division)
a ~/ b  // 3   (integer division)
a % b   // 1   (modulo/remainder)

Comparison

a == b   // false (equal)
a != b   // true  (not equal)
a > b    // true  (greater than)
a < b    // false (less than)
a >= b   // true
a <= b   // false

Logical

true && false   // false (AND — both must be true)
true || false   // true  (OR — at least one true)
!true           // false (NOT — flips the value)

---

Control Structures

Sequential

Code runs top to bottom, one line at a time. This is the default.

Selection (Branching)

Make decisions with if/else:

var hour = 14;

if (hour < 12) {
  print('Good morning');
} else if (hour < 17) {
  print('Good afternoon');
} else {
  print('Good evening');
}

Repetition (Loops)

Repeat actions without writing the same code:

// Count 1 to 5
for (var i = 1; i <= 5; i++) {
  print(i);
}

// Process each item in a list
var fruits = ['Apple', 'Banana', 'Cherry'];
for (var fruit in fruits) {
  print(fruit);
}

Nested Logic

You can combine these structures:

var scores = [85, 72, 93, 45, 68];

for (var score in scores) {
  if (score >= 80) {
    print('$score → Pass with distinction');
  } else if (score >= 60) {
    print('$score → Pass');
  } else {
    print('$score → Fail');
  }
}

---

Functions

A function is a reusable block of code that performs a specific task.

Why functions?
1. Don't repeat yourself (DRY)
2. Give your code meaningful names
3. Test pieces independently
4. Easier to maintain and debug

// Define
double calculateBMI(double weight, double height) {
  return weight / (height * height);
}

// Use it
var bmi = calculateBMI(70, 1.75);
print('Your BMI is ${bmi.toStringAsFixed(1)}');

Functions with Conditions

String getGrade(double score) {
  if (score >= 90) return 'A';
  if (score >= 80) return 'B';
  if (score >= 70) return 'C';
  if (score >= 60) return 'D';
  return 'F';
}

---

Debugging Basics

Your code won’t work perfectly the first time. That’s normal. The skill is learning to find and fix errors.

Types of Errors

Type	When	Example
Syntax error	Compile time	Missing semicolon, typos
Runtime error	While running	Division by zero, null access
Logic error	Wrong output	Wrong formula, off-by-one

Debugging Strategy

1. Read the error message carefully. It tells you what went wrong and where.
2. Print debugging — add print() statements to see what values your variables hold.
3. Narrow it down — isolate the problematic section.
4. Rubber duck debugging — explain your code line by line to someone (or something). Often you’ll spot the mistake mid-explanation.

// Print debugging example
double calculateDiscount(double price, double percent) {
  print('Price: $price, Percent: $percent'); // Debug line
  var discount = price * (percent / 100);
  print('Discount: $discount'); // Debug line
  return price - discount;
}

---

Problem Solving Framework

When you face a new problem, follow this process:

1. UNDERSTAND
   What is the input? What is the expected output?
   What are the constraints?

2. PLAN
   Write pseudocode or draw a flowchart
   Break it into smaller sub-problems

3. CODE
   Translate your plan into actual code
   Start with the simplest version that works

4. TEST
   Try normal inputs
   Try edge cases (empty, zero, negative)
   Try to break it

5. REFACTOR
   Clean up variable names
   Remove duplicate code
   Make it readable

---

Quick Reference

Concept	Key Idea
Decomposition	Break big problems into small ones
Pattern Recognition	Spot similarities, reuse solutions
Abstraction	Focus on what matters
Algorithm	Step-by-step instructions
Flowchart	Visual logic planning
Pseudocode	Plain English code
Variables	Named data containers
Control Flow	Sequential, selection, repetition
Functions	Reusable code blocks
Debugging	Find and fix errors systematically

---

What’s Next?

With solid programming foundations, you’re ready to learn about version control with Git & GitHub so you can collaborate with other developers and track your code history.

Bismillah, happy problem solving! 🚀