tools-only 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
- Maintain Clarity: Pseudocode should be easier to understand than the original code
- Be Consistent: Use the same conventions throughout the extraction
- Preserve Intent: Focus on the algorithm's purpose, not implementation details
- Use Natural Language: Write operations in plain English where possible
- Show Structure: Use indentation and keywords to make control flow obvious
- Add Context: Include brief comments for complex logic
- Stay Abstract: Avoid language-specific constructs unless they're conceptually important
- 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)