Book
  • Introduction
  • Welcome !!
  • Chapter 1: The mobile ecosystem
    • Fragmentation is the devil
    • There is more than one type of mobile app
    • ... more than one type of app
    • ... one type of app
    • Under pressure (ee da de da de) !!
    • Further reading!!
  • Chapter 2: Let's start with design thinking
    • A taste of design thinking
    • The five steps
    • Design for everybody
    • Accessibility in mobile apps
  • Chapter 3: Give me a context and I will give you an app
    • Users
    • Personas? Users ? What is the difference?
    • Please, help me to model the context
    • The context canvas
  • Chapter 4: Powerful models
    • Data architecture is the foundation of analytics
    • From data to information and knowledge
    • Information/Knowledge in our mobile ecosystem
    • Questions to ask yourselves when building and classifying questions
    • The visualization-data map
    • On the scene: describing how personas interact with your app
  • Chapter 5: A GUI is better than two thousand words
    • 'Good to Go:' Let's explore the Design Systems
    • Designing GUI Mocks
    • No prototype... no deal
  • Chapter 6: About mobile operating systems ... and other deamons
    • The Android OS ... son of LINUX
    • iOS son of Darwin? or is it iOS son of UNIX?
    • Kernels
  • Chapter 7: Yes, software architecture matters !!
    • Self-test time
    • About design and design constraints
    • Architects' mojo: styles and patterns
    • What you need is a tactic !!
    • Self-test time 2 (for real)
    • Further reading
  • Chapter 8: Finally... coding
    • MVC, MVVM, MV*, MV...What?
    • Programming models: the Android side
    • Hello Jetpack, my new friend... An Android Jetpack Introduction
    • Programming models: the iOS side
    • Controllers and more controllers
    • Flutter son of... simplicity
    • Programming models: Flutter?
    • Flutter: State matters... Let´s start simple
    • Flutter: State matters... Complex stuff ahead
    • Micro-optimizations
  • Chapter 9: Data pipeline
    • Generalities data pipelines
    • Data storage types
    • Types of data pipelines
  • Chapter 10: Error Retrieving Chapter 10
    • Eventual Connectivity on Mobile Apps
    • How to handle it on Android
  • Chapter 11: The jewel in the crown: Performance
    • As fast as a nail
    • Memory bloats
    • Energy leaks
    • Final thoughts
  • Chapter 12. Become a performance bugs exterminator
    • Weak or strong?
    • Micro-optimizations
    • The single thread game !!
    • Using multi-threading like a boss !!
    • Caching
    • Avoiding memory bloats
    • Further readings
Powered by GitBook
On this page
  1. Chapter 5: A GUI is better than two thousand words

No prototype... no deal

PreviousDesigning GUI MocksNextChapter 6: About mobile operating systems ... and other deamons

Last updated 1 year ago


(Free photo by Med Badr Chemmaoui on )

At the beginning of any project we tend to believe that we know everything useful to the project; we believe that if we spent a lot of time working in the project design we are completely ready to deliver a product or a solution that will be perfect for our users. That's not completely true, even if we did a great design phase, it is a fact that changes through the project development phase will be something mandatory to do. So, how do we know that we need to change something? How do we realize that there was something that we were missing in the design?

Well, the answer is that the only way to be sure is to test your idea and see how it works in a real environment. Like we learned in the chapter 2, prototyping is a way of making your ideas tangible, and find out quickly if you should devote more time and resources to them.

But, why are we talking about a chapter's 2 topic? Have the authors of this book ran out of ideas? There are no other important things to talk about at this moment? Well, no. Don't forget that design is a cycle, in which we are constantly checking our solutions. Prototyping is not only important when we are at the beginning of a project, there are multiple types of prototypes and multiple ways of prototyping, because in each phase of a project it is important to make them and test them with real users.

The life cycle of a project, that have already go through the design phase, should be: development - prototyping - development -prototyping and so on. A prototype gives you fast feedback and multiple insights about your idea. You need to use this tool to its best extend, try to check for everything you are not sure if is working, and pay attention even to the things that you think are perfect. Ask the users what they think about your solution, listen for suggested changes, and learn from each time you do this process. Prototyping is not only the release of a beta version of a product, is the process in which we spend time looking out for the release, gathering interactions in detail, trying to find the flaws and/or the improvements we can do.

Then, what about if you do a prototype now? At this time of the course, you have the UX, and you have already decided the colors and fonts for your application. Use one of more of the following techniques to make your prototype:

Manual Sketching

You can make a mockup by hand, drawing and using the right colors. You can even create a video to show how you think your app should work. But please, remember not to do vertical videos:

Remember that sketches and wireframes are used for the UX model, but mockups with colors, fonts, icons, images, etc are used for th e UI model.

Digital Prototyping

Arts are for sure something that we as engineers are not good at (most of us, it is not our intention to hurt you if you are an Engineer with an artist heart), thus, graphic design is not for us, but, the following web applications will help our UI model look pretty good:

(Video from . The video is published under the Standard YouTube license).

Glove and Boots
Marvel
Adobe XD
Sketch
Proto io
Invision App
unsplash