Alex, Jessie, Thomas, and Petter met in Room 4523 in the D building from 15-17:30. We worked on building our prototype (which is a low fidelity prototype with wizard of oz manipulation). We decided to go with this type of prototype since our solution to the museum challenge is a large game for children aged 7-12. We constructed most of the prototype, but there are a few things left to be completed:
Tree:
- Leaves for top (Johan)
- Bananas for top (Jessie)
- Color the trunk brown (Jessie)
- Drakis for Tree (Jessie)
Side Panels:
- Finish information for panels (Thomas)
- Translate the missing text panels into Swedish (Petter)
- Print out panels (Thomas)
- Glue A4s on the panels (Thomas)
- Get 2 more poster boards (Jessie emailed Pedro)
Sounds:
- Download sounds and make playlists (Alex)
- Record Swedish instruction (Johan Lindeberg)
I'd post a picture of what our prototype looks like so far, but that would ruin the surprise.
We will head to the Natural History Museum on Sunday (11/2) to do user testing!
Monday, October 27, 2014
Thursday, October 23, 2014
Team Meeting on October 22, 2014
Today we had another group meeting. Four of us met in a study room at KTH while Johan who is currently in Germany was available through chat.
The goal of the meeting was to decide all the details of how our sound room will run (process flow), as well as discussing the feedback we got from the other group in the latest exercise and use this feedback to finalize our project design. With the project design finished we will also be able to decide how to create our prototype, which will be the goal for our next meeting.
From previous meetings the task flow of our sound room looked like this:
Changes: During the meeting we made a couple of changes. First of all, instead of playing an animal sound once every 10 seconds, like suggested earlier, the sound will loop continuously for 30 seconds (or until the right animal is hit). Hitting the wrong animal no longer makes you lose the round, you can keep tapping the screens until you hit the right one. The only way to lose the round is if you have not yet pressed the right animal after 30 seconds, in which the game will continue to next animal. The new task flow can be seen here:
MISSING
Another thing that was added, as can be seen above, is some voice information during the game. This is to ensure that the kids know how the game will work and what to do. This was one of the feedback critiques we got, that the kids might not understand what to do when they enter the sound room.
Then we talked about the details of the scoring system. Since there are 10 animals you can get a maximum of 10 points, one point for each animal you have correctly identified. The amount of points you have are displayed on the tree in the middle. We also voted on whether to start the game by using motion sensor or a button, and it was in favor of a button. The button will be located on the ground around the tree, as seen in this sketch below. The tree will also have a reset button, in case you for some reason want to start over.
Finally we decided the layout of the screens. From top to bottom there will be a text box with some short information about the animal. This is mainly for adults to read, or read for their kids. As we have seen in earlier studies of our user group they are not very interested in text information. Below the text will be the picture/animation of the animal, and at the bottom of the screen the name of the animal in big letters.
Our next meeting will be the 27th of October. Then we will create our prototype as well as practice our wizard of oz presentation for the following user testing.
The goal of the meeting was to decide all the details of how our sound room will run (process flow), as well as discussing the feedback we got from the other group in the latest exercise and use this feedback to finalize our project design. With the project design finished we will also be able to decide how to create our prototype, which will be the goal for our next meeting.
From previous meetings the task flow of our sound room looked like this:
Changes: During the meeting we made a couple of changes. First of all, instead of playing an animal sound once every 10 seconds, like suggested earlier, the sound will loop continuously for 30 seconds (or until the right animal is hit). Hitting the wrong animal no longer makes you lose the round, you can keep tapping the screens until you hit the right one. The only way to lose the round is if you have not yet pressed the right animal after 30 seconds, in which the game will continue to next animal. The new task flow can be seen here:
MISSING
Another thing that was added, as can be seen above, is some voice information during the game. This is to ensure that the kids know how the game will work and what to do. This was one of the feedback critiques we got, that the kids might not understand what to do when they enter the sound room.
Then we talked about the details of the scoring system. Since there are 10 animals you can get a maximum of 10 points, one point for each animal you have correctly identified. The amount of points you have are displayed on the tree in the middle. We also voted on whether to start the game by using motion sensor or a button, and it was in favor of a button. The button will be located on the ground around the tree, as seen in this sketch below. The tree will also have a reset button, in case you for some reason want to start over.
Finally we decided the layout of the screens. From top to bottom there will be a text box with some short information about the animal. This is mainly for adults to read, or read for their kids. As we have seen in earlier studies of our user group they are not very interested in text information. Below the text will be the picture/animation of the animal, and at the bottom of the screen the name of the animal in big letters.
Our next meeting will be the 27th of October. Then we will create our prototype as well as practice our wizard of oz presentation for the following user testing.
Thursday, October 16, 2014
Reading Seminar 2 - Summary
In the reading seminar we went through the three chapters in chronological order and discussed the different concept quite in a loose manner. The main points of our discussion will be briefly summarized clustered by their respective chapter.
Related to chapter 7 we also talked about the laws and principles of interaction design, were we came to the conclusion that our design follows the principles of direct manipulation.
Moreover, we believe that keeping affordance in mind when designing the prototype is an important thing, as this concepts drives us towards and design that is as intuitive, simple and obvious as possible (i.e.; using the right shape, color, etc.). In terms of feedback and feedforward we classified our design / solution as that has to provide immediate feedback, particularly as response time is one of the pain points that we try to tackle.
When we came across the mental model and the different laws such as Fitt's or Hick's law we all believe that most of those laws can not easily be applied to our design. The only laws that we might use is Tesla's law (i.e.; shifting complexity from the user to the system), as well as Poka-Yoka (designing the task flow such as that errors become impossible).
Furthermore, we all agreed that we can't use standards or frameworks, simply because there is none, as we do not create a software in the classical sense.
In terms of documentation we depicted sketches and storyboards as our primary means to document the design. Another technique we want to make use of is task flow diagrams, which inherently also contains use cases (but in an non descriptive manner). Additionally, we also thought about creating a wireframe in order to convey the concept of our interaction principles in more detail.
When talking about prototyping we decided that a low-fidelity paper prototype would be the most suitable for our project. In order to be able to modify our prototype and by that add some kind of interaction we also want to make use of wizzard-of-oz-manipulation.
Regarding the development style we think that we are going to develop in an agile way, as we meet on a regular basis in order to meet short term milestones.
No, not necessarily, depends on the project
Q2: wireframe, is it necessary with every project?
We came to the conclusion that a wireframe is not a mandatory for every project.
Q3: are tasks and use cases related?
Yes, in the sense that task flows kind of contain use cases.
But use cases are a more detailed or "descriptive" explanation than tasks or task flows, whereas task flows are a more pictorial approach to describe a design.
Q4: When to use which mean to document a design?
Hard to answer/generalize, depends on the size and nature of a project
But for smaller projects it might be enough to only use sketches and storyboards, whereas for bigger more complex projects/products it might be beneficial to also use task flows and wireframes.
Chapter 6 - Ideation and Design Principles
We already had conducted our brainstorm session before we had to read chapter 6, 7 and 8 for the reading seminar. At this point it has to be remarked that it would have been more beneficial for us to read the literature first (Theory first!). However, retrospectively we adhered to the brainstorming rules mentioned in chapter 6. We also used techniques mentioned such as brain-writing (yes, and...), swiping, as well as we used pain points as a mean to kick-start each brainstorming round.Chapter 7 - Refinement
In our discussion related to chapter 7 we identified money and technology as the only two constraints that do not apply to our problem, whereas all the other constraint stated in this section apply.Related to chapter 7 we also talked about the laws and principles of interaction design, were we came to the conclusion that our design follows the principles of direct manipulation.
Moreover, we believe that keeping affordance in mind when designing the prototype is an important thing, as this concepts drives us towards and design that is as intuitive, simple and obvious as possible (i.e.; using the right shape, color, etc.). In terms of feedback and feedforward we classified our design / solution as that has to provide immediate feedback, particularly as response time is one of the pain points that we try to tackle.
When we came across the mental model and the different laws such as Fitt's or Hick's law we all believe that most of those laws can not easily be applied to our design. The only laws that we might use is Tesla's law (i.e.; shifting complexity from the user to the system), as well as Poka-Yoka (designing the task flow such as that errors become impossible).
Furthermore, we all agreed that we can't use standards or frameworks, simply because there is none, as we do not create a software in the classical sense.
In terms of documentation we depicted sketches and storyboards as our primary means to document the design. Another technique we want to make use of is task flow diagrams, which inherently also contains use cases (but in an non descriptive manner). Additionally, we also thought about creating a wireframe in order to convey the concept of our interaction principles in more detail.
Chapter 8 - Testing
In chapter 8 we found an important technique for us, which is called A/B testing. During the first round of sketching and designing we were occasionally faced with different design options. Hence, for such situations we can use A/B testing in order to let the user decide which way works best for him or her. When we spoke about the testing chapter we all agreed that we will follow the guidelines and create a test plan, as well as we will set up a test lab.When talking about prototyping we decided that a low-fidelity paper prototype would be the most suitable for our project. In order to be able to modify our prototype and by that add some kind of interaction we also want to make use of wizzard-of-oz-manipulation.
Regarding the development style we think that we are going to develop in an agile way, as we meet on a regular basis in order to meet short term milestones.
Questions
Q1: brainstorming - sketches?No, not necessarily, depends on the project
Q2: wireframe, is it necessary with every project?
We came to the conclusion that a wireframe is not a mandatory for every project.
Q3: are tasks and use cases related?
Yes, in the sense that task flows kind of contain use cases.
But use cases are a more detailed or "descriptive" explanation than tasks or task flows, whereas task flows are a more pictorial approach to describe a design.
Q4: When to use which mean to document a design?
Hard to answer/generalize, depends on the size and nature of a project
But for smaller projects it might be enough to only use sketches and storyboards, whereas for bigger more complex projects/products it might be beneficial to also use task flows and wireframes.
Team Meeting on October 15, 2014
Every group member was present.
To be done
- Redo design from feedback from previous evaluation
- Prototype
- Manual prototype, acting it out, record interaction
- User testing - we each need 1
- To be completed on 11/2
- Presentation -
- To be completed by exercise 6
Feedback that we are using to change part of our design:
- Expense. The evaluating team was concerned that giant touch screens are very expensive, can break easily, and will not last a long time. Solution: large plexiglass over a digital screen that children can push on. Basically this:
- Instructions: How will they know what to do? The way we are solving this is still up in the air. One idea is that the user’s presence is sensed by the game. The second idea is to have a start button around the tree like so:
- Here is another image from our ideas of our game flow from the meeting:
We will meet on 10/22 to work on the prototype. We will meet on 11/2 to do user testing.
Seminar 2 Reading Notes - Petter Janse.
For this seminar we were suppose to read three chapters about Ideation, Refinement and Prototyping. I think the content this time was a lot more interesting and suited for our project than the first seminar. The only thing I do not understand is why this seminar was not 1-2 weeks earlier, before we did the ideation exercise. Reading and discussing the theory before doing it in practice makes more sense to me than first doing it, and then learning about it.
None the less, the first chapter is about creating ideas for your project. It talks about the importance of brainstorming to get your project started and how it should be done most efficient. Something I noted though, is that the book says the brainstorming should not be made in words, but by sketches. Why is this? And why did we not follow this in the course? In our exercise we brainstormed ideas by writing them down. Another approach of ideation is what the book calls brainwriting which we also did during the exercise, though we called it something else. The idea is that someone starts with a basic idea, and then pass it on to the next person in the group that add something to it, and then pass it on. By keeping this chain going the idea will grow from something basic to a more detailed idea with the help of the whole group.
Chapter 6 also mentioned how to later try to filter out some ideas that might not work. This can be done by creating design principles, which is a sort of requirements that the ideas must pass to be accepted. In our project this was not as important since we did not have a many ideas to start with to filter out. But we did manage to eliminate some of them with the principles. For example when looking at the user group as an requirement we concluded that the GPS idea (as mentioned in previous blog posts) were really not intended for our user group and hence more or less discarded.
Chapter 7 goes deeper into the refining of your ideas. Some constraints are suggested to further filter out some of your ideas. But what would normally be the biggest constraints in a real project; time, money and technology we have all been told to not focus so much on, as long as the project is not completely unfeasible.
For the matter of direct or indirect manipulation our project has a very simple interface and will only use direct manipulation. The user will hear a sound and then press the screen which he think the sound came from. It does not get much more direct than that. Instead the biggest problem we will have to solve is that of affordances, how will we make it visually obvious how to use our sound room? While the idea is really simple, to push the screen you hear a sound from, a screen do not have the regular indicator that it is a button. This is something we have discussed a lot but still not found a good solution to.
Another thing that is mentioned in the literature which has played a big part of our project is the matter of feedback. We concluded early in our project, during the museum visit, that the feedback in a lot of their stations was very poor. Some simply because of slow computers, but others because of design. The book describe the delay between user input and the device output as latency and divides it in four stages, going from immediate (0.1s) to disruption (over 10s). One of the games I played at the museum made you answer a question and if you answered correctly a text block with information would pop up that you were expected to read. To ensure that the user would actually read it, the station locks, making you unable to press any buttons for as long as it would take to read it, hence creating an disruption. This was a big deal to us and we put it as one of our pain-points and decided our sound room should always have immediate feedback.
Because our project is so simple in practice, a lot of the laws mentioned in the book will not actually be relevant for us. For example Fitt´s Laws describe how buttons should look and be placed in a graphical user interface, making them easy to target and click. But the only "buttons" we will have are the actual screens with the animals. Hick´s law and the magic number seven describe the best way for a program to handle the presentation of multiple choices, as well as never having more than seven elements to keep track on. Again, in our sound room this will never be a problem.
The Poka-Yoke principle states that you should stop anything that can go wrong as early as possible (if you can not stop it from happening to begin with). However there is not much that can go wrong in our game. The worst case scenario is that the user do not understand how to start the game and play it. Concerning the start of the game we have had some discussions in the group of what kind of controls would be best used for this. Some people have suggested a button, while I am suggesting that it should be automated by motion sensors. My reasoning is that automating the process eliminates one thing that can go wrong (above principle), that the user do not understand he should press the button to start, or he might not even see it. I have tried to motivate the use of sensors with Poka-Yoke as well as Tesler´s Law of the Conservation of Complexity which states that it is good to move complexity from the user to the system to make it easier for them.
During our last meeting we realized there were a lot of details that we had not discussed yet for how the game is going to run. What happens if a kid hits the right screen? What happens if a kid hits the wrong screen? What happens if he does nothing at all? As to not miss any steps I decided to create a Task flow to simulate everything that can happen during a run, how the program should react to it, and what happens when it does. This is not a final product, but rather to be used as an overview of the system while working on it. I think it will help a lot.
The last chapter is about prototyping, something we are just about to start in our group. As we are aiming for as little text information as possible we will instead use sound effects and animations. The book gives a warning when using sound effects, that the user might grow tired or even annoyed of them after hearing them too many times. But this is more of an issue for a program that the user will use for a long period.
At the moment we are planning to do a low fidelity Wizard of oz manipulation. Meaning that we will simulate the finished product by manually controlling the prototype. We will use big posters with the printed animals on them and place them in a circle to "create" our sound room. The members of the group will then stand behind the posters, ready to play the sound (with a mobile) of the animal, as well as a happy or sad sound to give feedback whether they pressed the correct screen. Our hope is that the use of this together with a test group will get us answers to some questions that we have not been able to agree on, such as the starting of the game.
None the less, the first chapter is about creating ideas for your project. It talks about the importance of brainstorming to get your project started and how it should be done most efficient. Something I noted though, is that the book says the brainstorming should not be made in words, but by sketches. Why is this? And why did we not follow this in the course? In our exercise we brainstormed ideas by writing them down. Another approach of ideation is what the book calls brainwriting which we also did during the exercise, though we called it something else. The idea is that someone starts with a basic idea, and then pass it on to the next person in the group that add something to it, and then pass it on. By keeping this chain going the idea will grow from something basic to a more detailed idea with the help of the whole group.
Chapter 6 also mentioned how to later try to filter out some ideas that might not work. This can be done by creating design principles, which is a sort of requirements that the ideas must pass to be accepted. In our project this was not as important since we did not have a many ideas to start with to filter out. But we did manage to eliminate some of them with the principles. For example when looking at the user group as an requirement we concluded that the GPS idea (as mentioned in previous blog posts) were really not intended for our user group and hence more or less discarded.
Chapter 7 goes deeper into the refining of your ideas. Some constraints are suggested to further filter out some of your ideas. But what would normally be the biggest constraints in a real project; time, money and technology we have all been told to not focus so much on, as long as the project is not completely unfeasible.
For the matter of direct or indirect manipulation our project has a very simple interface and will only use direct manipulation. The user will hear a sound and then press the screen which he think the sound came from. It does not get much more direct than that. Instead the biggest problem we will have to solve is that of affordances, how will we make it visually obvious how to use our sound room? While the idea is really simple, to push the screen you hear a sound from, a screen do not have the regular indicator that it is a button. This is something we have discussed a lot but still not found a good solution to.
Another thing that is mentioned in the literature which has played a big part of our project is the matter of feedback. We concluded early in our project, during the museum visit, that the feedback in a lot of their stations was very poor. Some simply because of slow computers, but others because of design. The book describe the delay between user input and the device output as latency and divides it in four stages, going from immediate (0.1s) to disruption (over 10s). One of the games I played at the museum made you answer a question and if you answered correctly a text block with information would pop up that you were expected to read. To ensure that the user would actually read it, the station locks, making you unable to press any buttons for as long as it would take to read it, hence creating an disruption. This was a big deal to us and we put it as one of our pain-points and decided our sound room should always have immediate feedback.
Because our project is so simple in practice, a lot of the laws mentioned in the book will not actually be relevant for us. For example Fitt´s Laws describe how buttons should look and be placed in a graphical user interface, making them easy to target and click. But the only "buttons" we will have are the actual screens with the animals. Hick´s law and the magic number seven describe the best way for a program to handle the presentation of multiple choices, as well as never having more than seven elements to keep track on. Again, in our sound room this will never be a problem.
The Poka-Yoke principle states that you should stop anything that can go wrong as early as possible (if you can not stop it from happening to begin with). However there is not much that can go wrong in our game. The worst case scenario is that the user do not understand how to start the game and play it. Concerning the start of the game we have had some discussions in the group of what kind of controls would be best used for this. Some people have suggested a button, while I am suggesting that it should be automated by motion sensors. My reasoning is that automating the process eliminates one thing that can go wrong (above principle), that the user do not understand he should press the button to start, or he might not even see it. I have tried to motivate the use of sensors with Poka-Yoke as well as Tesler´s Law of the Conservation of Complexity which states that it is good to move complexity from the user to the system to make it easier for them.
During our last meeting we realized there were a lot of details that we had not discussed yet for how the game is going to run. What happens if a kid hits the right screen? What happens if a kid hits the wrong screen? What happens if he does nothing at all? As to not miss any steps I decided to create a Task flow to simulate everything that can happen during a run, how the program should react to it, and what happens when it does. This is not a final product, but rather to be used as an overview of the system while working on it. I think it will help a lot.
The last chapter is about prototyping, something we are just about to start in our group. As we are aiming for as little text information as possible we will instead use sound effects and animations. The book gives a warning when using sound effects, that the user might grow tired or even annoyed of them after hearing them too many times. But this is more of an issue for a program that the user will use for a long period.
At the moment we are planning to do a low fidelity Wizard of oz manipulation. Meaning that we will simulate the finished product by manually controlling the prototype. We will use big posters with the printed animals on them and place them in a circle to "create" our sound room. The members of the group will then stand behind the posters, ready to play the sound (with a mobile) of the animal, as well as a happy or sad sound to give feedback whether they pressed the correct screen. Our hope is that the use of this together with a test group will get us answers to some questions that we have not been able to agree on, such as the starting of the game.
Seminar 2 Reading Notes - Jessie Pease
The reading for Seminar 2 had the bulk of information necessary to complete the design process.
Chapter 6 taught us about Ideation and Design Principles. This chapter would have been much more helpful to read before our brainstorming process for the last two weeks.
Ideation can be broken down into a series of steps:
- Warm-up
- By this, they mean literally warm up your brain, hands, and mouths. In order to have a successful brainstorming session every group member need to be mentally, physically, and emotionally present.
- Set a Time Limit
- Without a time limit, brainstorming can feel like a lengthy, tiring, and never ending process. By setting a fixed time, you can have a sprint of ideas.
- When it comes to brainstorming, things to focus on are:
- paint points, opportunites, process moments, personas, and metaphors
- I really liked the different exercises they suggested for us to complete:
- Brain writing, Break the rules, Force fit, Poetry, Questioning, Laddering, Swiping, Bizarro world
- Organize Your concepts:
- Label and sort by criteria
- Creating design principles
- This is where you finally sit down and write down the concrete design requirements and potential solutions
- This comes after the crazy mumbo jumbo of creativity above
- These principles should be pithy, memorable, cross-feature, specific, a differentiator, and non-conflicting.
Chapter 7 was all about refining your brainstormed ideas. I will review the things I found most applicable to our team’s design problem.
- Affordances: This is appearances. How does your design look? Does it imply how a user would interact with it? The appearance needs to be contextual and cultural.
- This is one of our biggest issues because we don’t want to put written instructions on our game, so our design must be extremely innate.
- Feedback: Latency is a huge issue and often frustrates users or makes them have user errors.
- This is also one of our biggest pain points from our interviews. Our latency needs to be immediate, which means it needs to be .1 sec or less. More than that will cause children to lose complete interest in our game. They will likely be confused.
- Hick’s Law: The number of choices and how the choices are presented determines the amount of time it takes a user to complete a task and make a decision.
- This is very applicable to our game. If we gave the children too many choices for animals after they hear a sound, then it will be too difficult and they will feel defeated when they take a long time to get a correct answer. That being said, if there are too few choices, then it will be too easy and they will lose interest.
As we continue to develop our game, it will be crucial that we also use a site map sort of thing so that we know what happens with all the different use cases. Site maps focus on initiation, activation, and updates. For us we need to focus on start, correct answers, incorrect answers, end, winning, and many more cases. As we build our site map it could be helpful to create a story board or task flow to show off these use cases.
A large portion of this chapter talks about wireframes. Wireframes are extremely useful when it comes to websites and applications, but I think it would be very difficult to explain our game using a wireframe. It would be a lot more words than images since there is only one way the game is set up.
Even though we aren’t making a wireframe, and it is very complex, it does pose a lot of thoughtful questions and things to think about such as:
- non traditional inputs, gestural interfaces (how do your users move? how will they interact with it?), and presence.
Presence is something we are dealing with at this very moment. We are trying to decide whether or not we want the users to be sensed when they enter the game area in order to automatically start the game or not. The section about presence brought up a few important questions like: Will they feel like their privacy has been violated? Will they understand why they are being sensed?
Finally, chapter 8 is all about prototyping. In criticism, I would have liked if they pointed out specific prototyping tools. Although this may outdate their book, it could be quite helpful to hear what an expert thinks about specific tools.
Luke Wroblewski gave some specific advice about prototyping that are very applicable to our design:
- use audio cues sparingly
- instructional text is rarely read
- visual design shows importance and relationships between content
- personality of the design should reflect the designers
- common mistakes overstatements of visual contrast, too much emphasis on everything (basically simplicity is good!)
When making a prototype, there are different types. Ours will likely be a low fidelity prototype because we do not have the resources to create our large technical game. When we do testing, we can try A/B Testing. I think it will help us make our final complicated design decisions. One of our problems for testing is because our sub group is children, and we might have a hard time getting children to test our product, we might have to use some heuristic evaluation of our final prototype.
The end of the chapter spoke about agile development. Agile development is not something I am familiar with because I normally work on Security and Privacy engineering teams. If I ever work on a design team, it is now helpful to know how the agile development works.
Questions:
- Is it always necessary to make a wireframe?
- Did we do waterfall development for our project?
Seminar 2: Reading notes (Thomas Ziegelbecker)
Summary + Reflection
Chapter 6 elaborates on the gathering of design ideas (i.e.; concepts), which process is also called brainstorming or ideation. The main priority at this stage is to find as many concepts as possible (diverge first), where the authors recommend to use paper and sketches, rather then digital devices and textual description. We already applied a few of the guidelines and instructions, mentioned in this chapter, in our brainstorming session. For instance we adhered to the brainstorming rules, or we used pain points as a starting point. This refinement / converging (defining the details) of those ideas is the contents of chapter 7. In this chapter the authors recommend to use constraints, laws and principles (Fitt's Law, Hick's Law, George Miller's Magical No. 7, Tesla's Conservation of Complexity, Poka-Yoka) as guidance when doing so. They also mentioned that affordances (feedback and feedforward) are the key to a successful design, which is what the designer should provide to the user in order to allow for the best mental model which promotes a deep understanding of a product. For instance, one should follow Standards to reduce the need for the user to learn new things, according to the authors.The second part of the chapter was about elaborating on terms such as frameworks (metaphor, posture, structure), States and Modes (flow of navigation). In terms of framework I found the functional cartography interesting as I think that we can use it for our project. States are important, because by defining them we get a clear big picture for the prototype.
The rest of the chapter was about documentation (Sketches/Modes, Storyboards, Tasks, Use Cases, Mood Board, Wireframes) and when and how to use them. In our project we already used Sketches, Use Cases and a Story Board (Scenarios), where we will incorporate the chapters theory.
The very last part was about Controls and the differentiation between digital only and non traditional forms. The latter and the issues, which arise from it, will definitely be a of interest to us in later stages.
Chapter 8 was about interface design and the transition from the design to the actual prototype (low- vs. high-fidelity). In our case we agreed on building a low-fidelity paper prototype.
Chapter 8 was about interface design and the transition from the design to the actual prototype (low- vs. high-fidelity). In our case we agreed on building a low-fidelity paper prototype.
The last part of chapter 8 covered testing and gave tips of how to conduct a product test in the right way. For our project we incorporate two central tipps, which are setting up a test lab and writing a test plan.
Questions
- Do you really need to not use technical tools?
- When to apply which way of documenting?
- Do you always need a wireframe, do you always need to have Mood Boards, etc.?
- Does the way of documentation depend on the kind/size of the project?
Subscribe to:
Posts (Atom)





