Due: Monday (in class)
Format: 3 Teams, 10-minute presentation each
Goal: Design a clear, implementable workflow for the full system
Overview
We are now shifting from individual components (data, scoring, algorithms) to the complete system workflow.
Your task is to design how a user (gallery curator) interacts with the system from start to finish:
- adding artwork
- defining a show
- setting scoring preferences
- exploring layouts
- iteratively improving results
The focus is not code, but a clear, well-reasoned process that we can later implement.
Core Scenario
Assume the following:
- The gallery adds artworks to the system
- The user selects a subset of artworks to form a show
- The user defines scoring preferences
- The user selects a room or wall in the gallery
- The system generates layout proposals
- The user:
- views results
- tweaks scoring
- adjusts placements
- regenerates solutions
- The process repeats until a satisfactory layout is found
- The final result can be visualized wall-by-wall or room-by-room
Team Task
Each team will design a complete workflow for this system.
Your workflow should answer:
1. What are the stages of interaction?
- What are the major steps in order?
- What does the user do at each stage?
2. What does the user see and control?
- What pages or views exist?
- What inputs does the user provide?
- What outputs does the system generate?
Examples:
- artwork selection view
- scoring configuration page
- room/wall selection
- layout visualization
- iteration controls
3. How does iteration work?
This is the most important part.
- How does the user:
- evaluate a proposed layout?
- modify it?
- guide the next iteration?
- What kinds of input might be used?
- sliders (weights)
- manual adjustments
- accept/reject signals
- ranking or scoring layouts
4. What happens at different levels?
Your workflow should consider:
- wall-level layouts
- room-level layouts
- gallery-level layouts
How do these relate?
5. How does the system interact with algorithms?
The backend system will include:
- a Python interface
- plug-in algorithm components that:
- generate layouts
- evaluate layouts
- return results
Your workflow should describe:
- when the system calls the algorithm
- what inputs are passed
- what outputs are returned
- how user feedback influences the next iteration
Deliverables
Each team must produce:
1. Workflow Description
- Clear, step-by-step description of the system
- Written in a way that could guide implementation
2. Diagram (Required)
A visual representation of the workflow:
- flowchart, pipeline, or staged diagram
- must show:
- user actions
- system steps
- iteration loop
3. Presentation (10 minutes)
- Walk through your workflow
- Explain key design decisions
- Highlight:
- how iteration works
- how user input influences results
Guidelines
- Be specific, not vague
- Think in terms of actual screens and interactions
- Focus on clarity and usability
- Do not overcomplicate — aim for a system that is:
- understandable
- implementable
- extensible
Goal
After all presentations, we will:
- compare approaches
- identify strengths and weaknesses
- work toward a unified system workflow
This unified design will guide the next phase of implementation.
Looking Ahead
This work will directly support:
- algorithm integration (Python backend)
- iterative optimization (hill climbing, etc.)
- eventual system architecture design
