Pseudocode Extractor

Overview

Transform source code from any programming language into clear, language-agnostic pseudocode that captures the essential logic and control flow while removing syntax-specific details.

Extraction Process

1. Analyze Input Code

First, identify the programming language and understand the code structure:

• Recognize functions, classes, methods, and modules
• Identify control flow structures (loops, conditionals, error handling)
• Note data structures and their relationships
• Understand the overall algorithmic approach

2. Extract Core Logic

Focus on WHAT the code does, not HOW it's implemented:

Preserve:

• Function/method names and their purpose
• Control flow (if/else, loops, switch/case logic)
• Logical operations and conditions
• Data transformations and assignments
• Function calls and their relationships
• Class structures and inheritance relationships
• Key variable names that convey meaning

Filter out:

• Language-specific syntax (semicolons, braces, keywords)
• Type declarations and annotations
• Import/include statements (unless critical to understanding)
• Error handling boilerplate (try/catch unless the logic is important)
• Memory management details
• Language-specific idioms
• Verbose getter/setter methods
• Standard library implementation details

3. Format Pseudocode

Use clear, readable pseudocode conventions:

Structure:

FUNCTION function_name(parameters)
    // High-level description of what function does

    IF condition THEN
        action
    ELSE IF another_condition THEN
        another_action
    ELSE
        default_action
    END IF

    FOR EACH item IN collection DO
        process item
    END FOR

    WHILE condition DO
        action
    END WHILE

    RETURN result
END FUNCTION

Conventions:

• Use UPPERCASE for keywords (FUNCTION, IF, FOR, WHILE, RETURN, etc.)
• Use descriptive names in lowercase or camelCase
• Indent to show nesting and structure
• Use comments to explain complex logic
• Keep operations at a high level of abstraction
• Use mathematical notation where appropriate (←, ≠, ≤, etc.)

4. Organize Output

Structure the pseudocode to match the original code organization:

For single functions:

• Start with function signature
• Add brief description
• Show main logic flow
• Note return value

For classes:

• Show class name and inheritance
• List key attributes
• Show method signatures with brief descriptions
• Detail only the most important methods

For modules/files:

• Group related functions
• Show high-level module structure
• Indicate dependencies between components
• Use section headers for clarity

Examples

Example 1: Simple Function

Input (Python):

def calculate_discount(price, customer_type):
    if customer_type == "premium":
        discount = 0.20
    elif customer_type == "regular":
        discount = 0.10
    else:
        discount = 0.05

    final_price = price * (1 - discount)
    return round(final_price, 2)

Output (Pseudocode):

FUNCTION calculate_discount(price, customer_type)
    // Calculate final price after applying customer-specific discount

    IF customer_type is "premium" THEN
        discount ← 20%
    ELSE IF customer_type is "regular" THEN
        discount ← 10%
    ELSE
        discount ← 5%
    END IF

    final_price ← price × (1 - discount)

    RETURN final_price rounded to 2 decimals
END FUNCTION

Example 2: Loop with Data Processing

Input (JavaScript):

function filterActiveUsers(users) {
    const activeUsers = [];
    for (let i = 0; i < users.length; i++) {
        if (users[i].lastLogin !== null &&
            users[i].status === 'active') {
            activeUsers.push({
                id: users[i].id,
                name: users[i].name
            });
        }
    }
    return activeUsers;
}

Output (Pseudocode):

FUNCTION filter_active_users(users)
    // Extract active users who have logged in at least once

    active_users ← empty list

    FOR EACH user IN users DO
        IF user has logged in AND user status is "active" THEN
            ADD user.id and user.name to active_users
        END IF
    END FOR

    RETURN active_users
END FUNCTION

Example 3: Class Structure

Input (Java):

public class ShoppingCart {
    private List<Item> items;
    private double totalPrice;

    public ShoppingCart() {
        this.items = new ArrayList<>();
        this.totalPrice = 0.0;
    }

    public void addItem(Item item) {
        items.add(item);
        totalPrice += item.getPrice();
    }

    public void removeItem(String itemId) {
        for (int i = 0; i < items.size(); i++) {
            if (items.get(i).getId().equals(itemId)) {
                totalPrice -= items.get(i).getPrice();
                items.remove(i);
                break;
            }
        }
    }

    public double getTotalPrice() {
        return totalPrice;
    }
}

Output (Pseudocode):

CLASS ShoppingCart
    ATTRIBUTES:
        items: list of Item objects
        total_price: numeric value

    CONSTRUCTOR
        Initialize empty items list
        Set total_price to 0
    END CONSTRUCTOR

    METHOD add_item(item)
        Add item to items list
        Increase total_price by item price
    END METHOD

    METHOD remove_item(item_id)
        FOR EACH item IN items DO
            IF item.id equals item_id THEN
                Decrease total_price by item price
                Remove item from items list
                EXIT loop
            END IF
        END FOR
    END METHOD

    METHOD get_total_price()
        RETURN total_price
    END METHOD
END CLASS

Best Practices

1. Maintain Clarity: Pseudocode should be easier to understand than the original code
2. Be Consistent: Use the same conventions throughout the extraction
3. Preserve Intent: Focus on the algorithm's purpose, not implementation details
4. Use Natural Language: Write operations in plain English where possible
5. Show Structure: Use indentation and keywords to make control flow obvious
6. Add Context: Include brief comments for complex logic
7. Stay Abstract: Avoid language-specific constructs unless they're conceptually important
8. Group Related Logic: Keep related operations together for readability

Common Patterns

Conditional Logic

IF condition THEN
    action
ELSE IF another_condition THEN
    another_action
ELSE
    default_action
END IF

Loops

FOR i FROM 1 TO n DO
    action
END FOR

FOR EACH element IN collection DO
    process element
END FOR

WHILE condition DO
    action
END WHILE

REPEAT
    action
UNTIL condition

Data Operations

// Assignment
variable ← value

// Comparison
IF x > y THEN ...
IF x ≠ y THEN ...

// Collections
ADD item TO list
REMOVE item FROM list
FIND item IN list WHERE condition

Function Calls

result ← function_name(arguments)
CALL procedure_name(arguments)