Assignment 3 ​

User

Purpose A digital representation of a human

Principle After a user registers with a username and password, a person can represent that same user by re-entering in the same username and password.

register (n, p, u); authenticate (n, p, u')

State

registered: set User

username, password: registered -> one String

Actions/Sync register (n, p: String, out u: User) authenticate (n, p: String, out u: User)

Session[User]

Purpose authenticate user for extended period Principle //after a session starts (and before it ends), the getUser action returns the user identified at the start:start (u, s) getUser (s, u')

State active: set Session

user: active -> one User

Actions/Sync

start (u: User, out s: Session)

getUser (s: Session, out u: User)

end (s: Session)

Profile[User, <\Content>]

Purpose displays information about a particular user to an audience Principle When you view a profile, you can see information to learn more about the user that owns the profile State

bio: String

ProfilePic: Image

Posts: User -> set

count: User -> Number Item

Actions/Syncs Note: update includes add/delete

updateProfilePic(u:User, pic:Image)

updateBio(u:User, text: String)

updatePortfolio(u:User, c:<\Content>)

updateCollages(u:User, c: Collage)

storePost(u:User, p:Post)

Post<\Content>

Purpose allows users to communicate a thought or idea Principle Say user x creates a post with with text, audio, or video. After that post is made, depending on where it is made, other users are able to navigate to the post to see what user x wanted to share. State content: (Image + Video + Collage) datePosted: Post -> Date flair: Post -> Flair Actions sync make(f:Flair, u:User, target:Item, date:Date)

Collage<\User,Post>

Purpose allows users to store selected posts based on a user-determined theme for later reference

Principle When a user adds a post to a collage, they can go to the collage to find the post at a later time, instead of going to the user/place post was orginally made.

State name: String author: one User creators: set User lastEdited: User -> Date items: set Items private: Bool Actions sync addCollaborator(toAdd: User, owner: User) sync addItem(toAdd: Item, owner: User, date:Date) sync remove Item(toAdd: Item, owner: User, date:Date)

Space<\User,Items>

Purpose allows users to send items to the same group of users

Principle When a user joins a Space A with topic (a name representing the central theme of the Space) B, they can send and recieve posts related to topic B to/from the other users in the same Space A.

State users: set User topic: String bio: optional String count: Number -> one User filter: (any number) Label -> Content url: String posts: set Content -> (User & Date) Actions addUser(u:User) sync addPost(u:User, d:Date, p:Content) sync deletePost(u:User, d:Date, p:Content) removeUser(u:User) updateBio(u:String) updateBio(u:String)

Favorite<\Item, User>

Purpose allows users to save content for reference later Principle If a user favorites an item, they then reference the item from a item storage area State favorites: Item -> set Favorites Actions sync addFavorite(u:User, i:Item) sync removeFavorite(u:User, i:Item)

Message

Purpose enable users to communicate privately Principle When a user messages another user, they can send content between each other State sent, recieved: set Message -> User content: Content author: User author: User Actions sync sendMessage(a:User, b:User, c:Content)

Flair<\Item>

Purpose attach visible classification marks to items so filtering can be applied Principle When a flair is added onto an item, it is a visual way to denote the type of item it is and different behaviors can occur based on flair State name: String items: User -> String -> set<\Item> Actions sync addFlair(u:User, f:Flair) sync removeFlair(u:User, f:Flair)

Invitation<\Sender, Recipent>

Purpose allows the recipent to see whatever the sender sent Principle When an invitation is sent by a sender, the recipent can either deny or accept it State from, to: Invitation -> one User pending,accepted,rejected: set Invitation content: (String + url) Actions createRequest(u:User, u:User) acceptRequest(u:User, u:User) denyRequest(u:User, u:User)

Profile Matcher[Profile]

Purpose Allows users to dig through content and access the ones they like Principle When a user matches with a user, they send an invitation to talk one on one. State queue: seq(Item) seen/unseen: User -> User match: User -> User filters: set(Item)

Actions matchUser(a: User, b:User, match:Bool) removeFromQueue(a: User, b:User, match:Bool) sync updateQueue(a: User, new_filter:Item)

Comment<\Content>

Purpose allows users to share their thoughts response to specific content Principle When a user view some content c can respond to that contentwith a comment, which is essentially another piece of content that is only viewable by accessing the content it was made in response to. State comments: Content -> set Comment info: Content Actions/Sync editComment(a:User, newMessage:Content)

Designing the Marketplace

When making the app, I was conflicted on how to display the Marketplace. I wasn;t sure if I should make it so that a user can see multiple profiles at once, or just one profile. Also I wasn't sure if I should integrate features like payment into the app, filtering based on location, etc. I eventually decided to not add a location based marketplace as that could get quite complicated as with integrating payment into the platofrm like Depop Payments. Also I decided to only show one user at a time so the person swiping isn't overwhelmed with options.

Designing the Space Creation Process

When making the app, I was conflicted on how to structure the spaces. I wasn't sure if I wanted users to either: make spaces that expired/manually deleted, if all spaces should have an invite link or only private ones, and if all spaces should have a feed. I decided having a central feed is nice for any group, and expiring groups was extraneous, and any invite link is helpful for any space to be shared to someone outside of the app.

Users Following

When making the app, I was conflicted on how whether to allow users to follow each other. I thought it would be helpful to be able to follow your favorite accounts, but I decided against it because following is more complicated than what I intended user interactions to be. Instead, I realized my Favorite concept could be more generic, and Users could favorite other Users so they can go back to their profiles easier.