الشيفرة الزائفة والمخططات الانسيابية

Written Explanation

What pseudocode is

Pseudocode is plain language with code-like structure. It is not a real programming language, so no compiler reads it and there are no syntax errors. Its purpose is to make the logic visible: the order of the steps, the repeated parts, and the decisions.

A common vocabulary keeps it readable. These words are conventions, not rules, and many courses use slightly different ones:

Indentation is the one structural rule worth keeping: everything inside a loop or a decision is indented under it, so the reader can see where it starts and ends.

Good pseudocode and bad pseudocode

Good pseudocode is precise about logic and relaxed about syntax. Compare:

Too vague:     Find the biggest one.
Good:          SET largest = first value
               FOR EACH other value
                   IF value > largest
                       SET largest = value
               RETURN largest
Too much Java: for (int i = 1; i < a.length; i++) { if (a[i] > max) max = a[i]; }

The vague version hides the loop and the comparison. The "too much Java" version spends attention on semicolons and brackets. The middle version names the variables, shows the loop, and shows the decision, but it has no braces and no types.

A good test: could a friend who has never seen your problem follow it and get the right answer by hand? If yes, the pseudocode is good enough.

What a flowchart is

A flowchart draws the same logic as shapes joined by arrows. The common conventions are:

A diamond holds a question that can be answered yes or no, such as value > largest?. Each of the two arrows leaving it is labelled. A loop shows up as an arrow that goes back to an earlier shape.

Since we cannot draw boxes here, the flowcharts in this lesson are written as text. Rectangles are [ ], diamonds are < >, and arrows are described by lines and labels:

[Start]
   v
[SET largest = first value]
   v
[SET i = 1]
   v
<i < length?> --no--> [RETURN largest] --> [End]
   | yes
   v
<values[i] > largest?> --no--+
   | yes                     |
   v                         |
[SET largest = values[i]]    |
   v                         |
   +-------------------------+
   v
[SET i = i + 1] --> back to <i < length?>

I have used the shape conventions that are widely taught; whether your course or tool draws them exactly this way can vary, so follow your instructor's version if it differs.

Which one to use?

Pseudocode suits loops, calculations, and logic with many steps; it is faster to write and closer to code. A flowchart suits decisions with several branches and explaining the logic to non-programmers, because it shows every path at a glance. For many problems pseudocode alone is enough.

Finding mistakes in the plan

The value of a plan is that you can check it cheaply. Ask three questions of any pseudocode:

1. Does every variable have a value before it is used? (Did you SET largest before comparing?)
2. Does every loop end? (Does something inside change the condition?)
3. Does every decision cover all cases? (What happens in the ELSE?)

Then run your plan on the example from the first lesson. The next lesson turns this into a precise technique.

From pseudocode to Java, and keeping both

When the plan looks right, translate it line by line. SET becomes an assignment, FOR EACH becomes a for loop or an enhanced for, IF stays if. If you change your mind while coding, change the plan too, so the plan and the code always describe the same program. A plan that no longer matches the code is worse than no plan.