Part 3: Convergent Design
Functional Design
Concepts
Concept: Tag[Item]
Purpose: To add additional groupable attributes/context to an item
Operational Principle: When trying to find an Item, a user can find it by searching for one of the tags they added to it.
State:
tags: set Tag
value: Tag → one String
taggedItems: Tag → many Item
thresholdNumber: Tag → one Number
Actions:
createTag(s: String, tn: Number):
tags += Tag(value=s, thresholdNumber=tn)
addItem(t: Tag, i: Item):
taggedItems[t] += i
removeItem(t: Tag, i: Item):
taggedItems[t] -= i
getUserItems(out: set Items, u: User):
return {item for item in tag for tag in tags if item.user == u}
getUserItemsByTag(out: set Item, u: User, t: Tag):
return {item for item in tags[t] where item.user == u}
Concept: Item[UserT]
Purpose: A digital representation of a real world object
Operational Principle: During use, a User can add their physical items into the app as an Item to help keep track of it.
State:
items: set Item
name: Item → one String
location: Item → opt Location
purpose: Item → opt String
lastUsedDate: Item → opt Date
user: Item → User
Actions:
createItem(out Item, user: User, name: String, location: Location, purpose: String, lastUsedDate: Date):
i = Item(user, name, location, purpose, lastUsedDate)
return i
deleteItem(i: Item):
items -= i
Concept: Achievement[User]
Purpose: Tracks whether a specified objective is completed
Operational Principle: When a certain objective is completed, the User will earn the achievement.
State:
const NAMES: set achievementName
maxProgress: one achievementName -> one Number
achievements: set Achievements
owner: one Achievement -> one User
completed: one Achievement -> one Boolean
achievementProgress: one Achievement -> one Number
name: one Achievement -> one achievementName
Actions:
create(u: User):
for n in NAMES, add (u, n, False, 0) to achievements
progress(u: User, n: achievementName, amount: Number)
achievementProgress += amount
if achievement is completed, completed = True
Concept: Point[User]
Purpose: Adds value to completing tasks
Operational Principle: Users will earn points when they complete certain tasks. The amount of points earned depends on the task.
State:
Points: number
Owner: points -> one User
Action:
addPoints(u: User, n: Number):
points[User] += n
getPoints(u: User)
return points[User]
Concept: Survey [UserT, ItemT]
Purpose: to collect information from users
Operational Principle: When a user responds to the survey, it will collect their responses.
State:
question: set String
questionType: question -> one String
response: UserT, question, ItemT -> one Answer
Actions:
getQuestions(out q: set String)
return question as q
respond(u: UserT, q: String, i: ItemT, a: Answer)
add(u, q, a) to response
getResponse(u: UserT, q: String, i: ItemT, out a: Answer)
return (u, q, i) from response
Concept: Recommendation [TagT]
Purpose: prompts a user
Operational Principle: When a user receives a recommendation, they can either accept it and perform the action or reject it.
State:
rec: set String
recTypes: TagT -> one rec
Actions:
getRecommendation(i: ItemT, t: TagT, out recStr: String)
return some String combining i and r from rec if r.recTypes == t
Concept: Plan [UserT, TaskT]
Purpose: Organize a set of tasks for a user by deadline.
Operational Principle: Users will have a personalized plan where they have to complete specific tasks for a specific date/time.
State:
plans: set Plan
assignee: Plan -> one UserT
tasks: Plan -> set TaskT
deadline: Plan -> one Date
Actions:
getTasksAtDate(u: UserT, d: Date)
return tasks for Plan with assignee == u and deadline == d else None
generatePlan(u: UserT, d: Date, tS: set TaskT):
tasksAtDate = uniformly pick 3 tasks from tS
create (u, tS, d) in plans
expiredTaskT(u: UserT):
curDate = Date.now()
delete plan in plans with deadline < curDate and assignee == u
Concept: Task [UserT, Rec, ItemT]
Purpose: Provide users with an objective or goal Operational Principle: When a condition is met, an user will receive a task and they will have to execute the required set of actions to complete the task.
State:
tasks: set Task
objective: Task -> one Rec
assignee: Task -> one UserT
item: Task -> one ItemT
Actions:
assign(u: UserT, o: Rec, i: ItemT)
if (u, o, i) not in tasks
add (u, o, i) to tasks
complete(u: UserT, o: Rec, out i: Item)
item = item from tasks where u == assignee and o == objective
delete (u, o) from tasks
return item
isAssigned(u: UserT, o: Rec, i: Item)
return (u, o) in tasks
App Level Actions
app NixKnack
include Item
include Tag[Item]
include User
include Achievement[User]
include Point[User]
include Survey[User, Item]
include Survey[User, Item]
include Recommendation[Tag]
include Task[User, Recommendation, Item]
include Plan[User, Task]
sync createItem(user: User, name: String, location: Location, purpose: String, lastUsedDate: Date, tags: set Tag):
when item = Item.createItem(user, name, location, purpose, lastUsedDate):
Tag.addItem(tag, item) for tag in tags
Achievement.progress(user, Achievement.NAMES.itemsMade, 1);
if size(tag.taggedItems) > tag.thresholdNumber for any tag in tags:
return getRandomQuestion
sync completeTask(user: User, rec: Recommendation):
Survey.getQuestions()
item = Task.completeTask(user, rec)
Tag.removeItem(item, tag)
Item.delete(item)
Point.addPoints(user, 10)
Achievement.progress(user, Achievement.NAMES.completedTasks, 1)
sync generatePlan(user: User)
userItemsByTag = Tag.getUserItems(user)
tagAndUrgencyPool = { tag : (len(userItemsByTag[tag]) - tag.thresholdNumber) for tag in userItemsByTag if len(userItemsByTag[tag]) > tag.thresholdNumber }
recPool = { Recommendation.getRecommendation(item, tag) for item in userItemsByTag[tag] for tag in random.choice(userItemsByTag[tag], tagAndUrgencyPool[tag]) }
taskPool = { Task.assign(user, rec) for rec in recPool }
x = 6
while Plan.getTasksAtDate(u, Date.currentDate + x) is None and x >= 0
Plan.generatePlan(user, Date.currentDate + x, taskPool)
x -= 1
sync addPointsAchievement(user: User, points: Number):
Point.addPoints(user, points)
Achievement.progress(user, Achievement.NAMES.totalPoints, points)
Dependency Diagram
Wireframes
Heuristic Evaluation
Usability Criteria
Learnability
- The plan interface is very simply laid out in day order, and checking a box is very intuitive
- Item searching is very logically organized with the search bar and the item tiles with photos
- It’s evident what achievements are and it’s clear that they exist from the profile, although it’s not necessarily clear what the next steps to gain an achievement are
- The discard button is only located in the item view, but it’s large and not hard to find.
Error Tolerance
- Items can be edited if wrong information was added, or discarded (although discards count towards the statistics, which might not be preferable in the case of an accidental add)
- Discards cannot be undone
- Username and passwords can be changed at the user’s discretion, whether they entered it wrongly originally or they just want something different
- Change password is only a single (not double) confirmation which is error prone
Physical Heuristics
Fitt’s Law
- Each NikKnack icon on the homepage, as well as every section of the plan and profile, incorporates clear and adequate spacing to separate each subsection.
- The items featured on the home page are sufficiently sized, ensuring easy differentiation between each item and facilitating specific item selection.
- Buttons, whether for editing, discarding items, or the icons on the bottom bar, are all sufficiently large, promoting easy pointing and interaction for users.
- The search bar is not amply sized which can make it difficult to click on and search for items.
- Task icons on the plan page are not appropriately sized, which can make it difficult for users to complete a task.
Situational context
- All page views are labeled, e.g. “Your Plan,” “Your Profile”
- Additionally, the main pages have icons in the navbar, and the icon representing that page will be highlighted for easy visual cueing
- Checkboxes tell a user whether they’ve completed a task or not
- Achievement icons tell the user what achievements they have, as well as what level of achievement
- There is no indication of how far a user has to go until the next achievement
Linguistic Level
Information scent
- Upon logging in, users are directed to the home page, featuring a prominent display of items for immediate viewing.
- The page title, "Your KnickKnacks," serves as a clear indicator that the icons on the page represent the items logged by the user.
- The bottom toolbar, with familiar icons found in various apps, suggests pages for users to explore next, with each icon clearly indicating its purpose.
- The plus button adheres to the common design choice for such buttons in different apps, ensuring clarity for new users regarding the function of each button on the home page.
- Clickable icons for KnickKnacks open new pages with explicit item descriptions and clear buttons for potential actions.
- The plan and profile pages offer users clear actions, with the plan layout presenting distinct tasks for the user to follow.
Consistency
- Every page of the application has consistent styles and color palettes.
- Our app adheres to the well-established format of apps in the market, using easily recognizable icons to represent specific functions. The use of familiar and commonly used icons in the application allows users to use their prior knowledge of apps to guide their use of our application, ie. plus to create new items, searching for items using search bar, going to profile page using the person icon, etc.
- The font and design is consistent across different pages of the app with clear layouts and spacing between each subsection of the page.
- The way points are displayed differ from the way other apps display points. It is a bit unclear what points are used for.
Visual Design Study
Project Plan
P4: Alpha Release (Nov. 29 11:59pm)
P5: Beta Release (Dec 6 11:59pm)
P6: Final Build & User Testing (Dec 12)
If when the deadline approaches for Beta Release we do not have everything completed, we will consider dropping the achievement and points features. We can also drop the recommendation concept and have tasks be discarding an item without a specific recommendation for how to discard the item. If things go very wrong, then we will cut Plan and just have an app to help the user organize and see the items they have.
Order of Concepts divided into stages:
User (Rachel by Nov 27th)
a. Figure out structure of collection in MongoDB (Nov. 25th)
b. Complete the concept class (Nov 26th)
c. Implement REST routes where necessary (Nov 27th)
d. Complete concept syncs (Nov 27th)
Item (Rachel by Nov 28th)
a. Figure out structure of collection in MongoDB (Nov 25th)
b. Complete the concept class (Nov 27th)
c. Implement REST routes where necessary (Nov 28th) d. Complete concept syncs (Nov 28th)
Task, Survey, and Tag (Rachel by Dec 4th)
a. Figure out structure of collection in MongoDB (Nov 28th)
b. Complete the concept class (Dec 1st)
c. Implement REST routes where necessary (Dec 2nd)
d. Complete concept syncs (Dec 3rd)
Recommendation and Plan (Lauren by Dec 4)
a. Figure out structure of collection in MongoDB (Nov 25th)
b. Complete the concept class (Nov 27th)
c. Implement REST routes where necessary (Dec 1st)
d. Complete concept syncs (Dec 4th)
Achievement and Point (Lauren by Dec 4)
a. Figure out structure of collection in MongoDB (Nov 28)
b.Complete the concept class (Dec 1)
c. Implement REST routes where necessary (Dec 2)
d. Complete concept syncs (Dec 3)
Front End
Home Page (Caleb by Nov 29th)
a. Catalog Display
Plan Page (Caleb by Nov 30th)
a. Outline
b. Tasks
Profile Page (Adrian by Nov 28th)
a. Achievements (Dec 5th)
b.Settings (Nov 28th)
Item Screen (Adrian)
Adding an Item (Caleb by Nov 29th)
Survey (Adrian)
Search (Caleb by December 5th)
User Testing
- User Testing Tasks (Group meet up to come up with tasks Dec 8th)
- Interview Person and Writeup (Each person does one User Testing Dec 12th)