Let's review the design process in a nutshell. It is helpful to think about the design process as a highly iterative process consisting of four main stages. At the start of the process, the designers are involved in trying to understand the design space and trying to understand the actual problems that their users are trying to solve in order to better conceptualize what the design problem actually is that they need to be addressing. After that, they often move into the exploration of the solution space which is typically done with practices such sketching and brainstorming where designers use the process of ideation to create many many different alternatives for potential solutions for the design problem that they identified. This particular stage of the process is all about creating large numbers of different ways in which the design projects can be done and the problem addressed so that designers have a platter of material from which to work to synthesize an effective design solution as part of synthesizing the solution. Then, they move into a set of practices that include deciding what exactly the scope of the project is, what constraints they need to be considering in defining what kind of solution is likely to be effective, and then creating a range of representations such as design scenarios, storyboards, and personas that are intended to concretize their understanding of the design problem in a way that allows them to more effectively move to the actual planning of the design solution. Finally, and this is going to be the part that we focus on in this course, the designers move to actually planning the solution that they're going to implement in code down the line. This process we typically refer to as prototyping. It involves creation of a number of different kinds of representations such as wireframes, low fidelity prototypes, mockups, and medium fidelity prototypes. Then, all of these representations are iteratively evaluated with users to get feedback on a number of questions that designers have as they move through the process so that they can refine their solutions, they can revise them and come up with something that is going to be useful and usable for the end users. Again, this is a highly iterative process. Even though these four stages look like they happen in sequence, in reality, designers move back and forth among them as they move through the process to both better to understand the problem that they're trying to solve to then move to the parts of the process that allow them to more effectively make progress on to the next step. As I mentioned, as the designers engaged in this process, they create a number of design representations from the representations of their early user research such as the affinity wall, that you see here in the picture, to representations on ideal users that they're designed solution is going to be targeting; these we've referred to as personas and here on the screen you have an example of such a persona, onto design scenarios that begin to move the designer's understanding of the design problem towards some sense of what the solution might look like. Scenarios, as we discussed in the last course, are short stories that concretize for designers and for other members of the design team exactly what designers believe that the technology should be doing and how the users are going to be using it as part of their daily lives. It's done in a narrative form allowing a lot of flexibility for both understanding what the technology is doing and how the technology might be affecting both the user's own lives and the lives of people around them. Finally, once those tensor representations that created, designers move towards actually mocking up what an actual system is going to look like, and that is the material that we are going to be covering in this course. This process is called prototyping. It refers to the process of translating the findings from the formative work into concrete designs that can be tested, revised, and refined prior to implementation of the final system in code. This is really important to understand, that the actual coding of the system is something that happens only at the very end of the design process. Until that point, all of the design is done at the level of plans, at a level of prototypes that the designers work on in quick and iterative ways so they can revise these plans as often as is needed to arrive at an effective solution. Prototyping is a set of practices that allows this kind of flexibility and iterative process to happen before any of the solutions are actually coded up.