Showing posts with label Seminar 2 notes. Show all posts
Showing posts with label Seminar 2 notes. Show all posts

Thursday, October 16, 2014

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.

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:
  1. Warm-up
    1. 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. 
  2. Set a Time Limit
    1. 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. 
    2. When it comes to brainstorming, things to focus on are:
      1. paint points, opportunites, process moments, personas, and metaphors
      2. I really liked the different exercises they suggested for us to complete:
        1. Brain writing, Break the rules, Force fit, Poetry, Questioning, Laddering, Swiping, Bizarro world
  3. Organize Your concepts:
    1. Label and sort by criteria
  4. Creating design principles
    1. This is where you finally sit down and write down the concrete design requirements and potential solutions
    2. This comes after the crazy mumbo jumbo of creativity above
    3. 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. 

  1. 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. 
    1. 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. 
  2. Feedback: Latency is a huge issue and often frustrates users or makes them have user errors. 
    1. 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. 
  3. 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.
    1. 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. 
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? 

Seminar 2 notes - Johan Lindeberg

After I read through the chapters and wrote down my notes, I had a discussion with my group, and realized the chapters are not the same in the 2006 edition of the book which I have. I hope it does not matter too much, as there were still a lot of good information.

I found quite a lot of interesting concepts readnig thorough these chapters, although not too many that are applicable for our project. The real-world examples made the concepts easier to grasp, and almost all of them were quite interesting, such as Gmail with Google talk where engineers made a proof-of-concept, while designers made sketches and mockups changing the by engineers created modal interaction, into a less obstructive one. The case study also related back to what was previously discussed about visual design in the chapter, such as having new chat messages pop up in high contrast for higher awareness of the user. 

Something I never thought about is that the "save-button" in almost all applications are shown as a floppy disc, although younger people today probably don't even know what a floppy disc is, it's hard to think of a symbol which could replace this.

Reading about ambient devices, and the example of a parking structure where the outside of the building indicates how full it is inspired me to try and incorporate something like this in our own design project, maybe in some way we could have the floor / walls of our "Circular sound room" to guide users. 

The examples regarding the BBC website and Amazon really showed how multitasking could be done well. On the BBC site, pages you visit more frequently gradually shows a darker blue color, which makes the website easier to navigate. And Amazon with their functionality of "People who bought this also bought.." and "What did users ultimatley buy after viewing this product?".

"BBCi and Amazon made completing tasks in the future easier and more
interesting for users, and that's something worth designing. Note, too, that
users don't have to set preferences or tell either of these sites what they are
interested in doing. The sites learn this from behaviors their users are already
engaged in. The onus isn't on users to customize their experiences; the sites
themselves are smart enough to do it. They multitask."
from Designing for Interaction, on Multitasking

The author also brought up that these changes work so well because they are subtle. Microsoft's Clippy from the earlier Word versions is a great example of unsubtle multitasking. I don't think I've ever heard anyone praise the functionallity of Clippy.

Question: Is there some way to make our project idea adaptive, or make use of multitasking?

Wednesday, October 15, 2014

Seminar 2 Reading Notes - Alexander Hoffmann

I also had the wrong edition of the book. But the concepts from there are quite fitting as well for the design process at out recent point.

It was explained how to come up with concepts using creative methods like Brainstorming. We used the pain points to start from and developed some ideas that were quite open(diverging). Even though we didnt read the chapter before the seminar we used the suggested way of only paper sketches.

For the Layout of our product we have something quite simple in mind. Since small children have to understand it few elements and clear placing of them is important. The flow of the animations has to be that way too. By using colors and sounds to indicate right or wrong answers we can easily and immediately show the result of the input and they will perceive it through the sound even if they dont look in the right direction at that moment. To keep it simple we will stick to the most basic type of controls: buttons.
By using general Icons that are well known (standards) we dont have to use words and that is good as well since the children dont have to read.
Presence is important as well. our system could start when someone enters the room and does not reset until everyone is outside.

Designing for connection: since our machine is local and could be connected to the internet it could comprehend a lot. but the question is what is useful. maybe repeating the difficult questions more often would be one use of memory because our users are changing all the time. (Adaption)
the other ways (customization and personalization) are not helpful because of the multi user aim of our product. same goes for flow, since our users will only spend a short amount of time with the product it will be limited to maybe start with the easy questions so every child gets the purpose of the game.
The guidelines for creating adaptive products are very useful for the more detailed design of our product. With those principles in mind we can provide a better fit of our game.
We will include some kind of ambient technology to express that the system is running but the game has not started yet. This way it doesn't look dead but users will notice the change when it actually starts.