Axure RP 6 Prototyping Essentials

Ezra Schwartz

• Publisher: Packt Publishing
• Year: 2012
• ISBN:
  9781849691642
• Edition: 1
• Topic: Conception
• Subtopic: Conception de l'IU/EU

In Detail

Wireframes, interactive prototypes, and UX specifications are among the fundamental deliverables of every UX project. They are also the most labor and time intensive to produce due to constant changes in business requirements. Given these circumstances, Axure is quickly taking over as the preferred tool for prototyping. However, prototyping in Axure is strikingly different from the conventional method of producing static wireframes and to rapidly develop interactive prototypes in Axure, you'll need to have a good understanding of the tool and its features.

Whether you are an individual practitioner or a member of a UX team, a consultant, or an employee, this book will teach you how to use Axure, one of the leading UX tools. You will learn to use Axure for producing top-quality deliverables and tackling the demands of rapid iterative UX projects of any complexity and size, and for any platform and device.

Axure RP 6 Prototyping Essentials takes a very pragmatic approach to showing you how to use Axure and produce impressive deliverables while saving labor and time. You may not be in a position to change how projects are scheduled, budgeted, and managed, but you can be more creative and productive by mastering one of the leading UX tools in the market.

After an initial introduction to Axure's user interface, terminology, and features, this book walks you through a medium-size UX project: a digital library that sells books, newspapers, and movies. Although some aspects of the prototyping process are simplified for the sake of clarity and efficiency, the demo project is an opportunity to discuss in context and in sequence topics such as addressing business and technical requirements, handling use cases and flow diagrams, low and high fidelity wireframe construction, interactivity, writing annotations, generating detailed UX specifications, and traceability.

For the most part, Axure 6 RP Prototyping Essentials can be read in sequence or used as a reference guide.

Approach

Axure RP 6 Prototyping Essentials is a detailed, practical primer on the leading rapid prototyping tool. Short on jargon and high on concepts, real-life scenarios and step-by-step guidance through hands-on examples, this book will show you how to integrate Axure into your UX workflow.

Who this book is for

This book is written for UX practitioners, business analysts, product managers, and anyone else who is involved in UX projects. The book assumes that you have no or very little familiarity with Axure. It will help you if you are evaluating the tool for an upcoming project or are required to quickly get up to speed in a project you just joined. The book assumes some familiarity with the principles of the User Centred Design methodology.

Axure RP 6 Prototyping Essentials

---

Table of Contents

Axure RP 6 Prototyping Essentials

Credits

Foreword

About the Author

Acknowledgement

About the Reviewers

www.PacktPub.com

Support files, eBooks, discount offers and more

Why Subscribe?

Free Access for Packt account holders

Instant Updates on New Packt Books

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Downloading the example code

Errata

Piracy

Questions

1. Prototyping Fundamentals

The art of UX prototyping

Prototyping interaction

The prototyping checklist

The project

Simple websites

Web applications and portals

Mobile apps

Heuristic evaluation

User validation

Deliverables: Prototype and specifications

Balancing act: What stakeholders have to say

Business stakeholders

Management

Business process architects

Project management

Visual design

Development stakeholders

The UX perspective

The UX practitioner

The UX team lead

The challenge

Team structure

Process

Extending the process

Axure: The Good

Axure: The Bad

Tips for using Axure on large design projects

Axure around the world

The Axure perspective

Summary

2. Axure Basics—the User Interface

Getting started

Working with multiple project files

The Axure workspace

Customizing the workspace

The Sitemap pane

Wireframe pages

Flow pages

The Page Properties pane

Page notes

Managing notes

Page interactions

Page formatting

Sketch effects

The Widgets pane

Wireframe Widgets

Flow widgets

Creating your own widget library

Third party widget libraries

The Widget Properties pane

Annotation tab

Annotation fields

Annotation views

Interactions tab

Interactions

Events

Cases

Actions

Formatting tab

Location and size

Font

Alignment + Padding

Style

Ordering

Fills, Lines, + Borders

The Wireframe pane

Grid and Guides

The Masters pane

Master behavior

Normal

Place in Background

Custom Widget

Usage Report

The Dynamic Panel Manager

The toolbar and menu bar

Axure file formats

The .RP file format (stand-alone)

The RPPRJ file format (shared project)

Summary

3. Prototype Construction Basics

Prototyping principles

Alexandria, the Digital Library Project

Getting started—productivity in 30 minutes

Initial requirements and use cases

Use case diagram page

Saving the project file

First wireframe pages

Task flow diagram page

Browse path flow diagram

Search path flow diagram

Link use cases to flow diagrams

Generating the HTML prototype

Getting started with masters and dynamic Panels

The first wireframe

The quick and dirty approach

The quick but structured approach

First masters: navigation systems

Global navigation bar

Secondary navigation system

The first dynamic panel

Adding states to a dynamic panel

Adding visual effects

Adding sketch effects

Updating task flow diagrams

Practitioner's corner—Axure prototyping for mobile devices

Mobile-friendly websites and mobile apps

Different device resolutions and aspect ratios

Using the Viewport Tag

Using a full screen browser

Landscape and portrait page versions

Event and gesture compatibility

Browser limitations

Using widget libraries

Loading prototypes onto the device

Summary

4. Interactivity 101

Interaction design—brief history

The 1950–60s

The 1970–80s

The 1990–2000s

The present, future, and Axure interactions

Axure interactions primer

Guided example

Step 1: Defining the interaction in simple words

Step 2: The Axure interface

Step 3: Translating this requirement into an Axure interaction

Step 4: Annotating the interaction (optional?)

Axure events

Events triggered on OnPageLoad

Guided example: Changing the default landing page

Simulating contextual navigation

OnPageLoad events and dynamic panels

OnPageLoad event in detail

User triggered events

Guided example: Sign-in

Construction strategy

Adding the interaction

Organizing actions

Widget, Events, and Context

Widget Events in detail

Axure cases

Guided example: Construction and interactions

Part 1: Construction tweaks

Part 2: Adding interactions

Axure actions

Links actions

Dynamic panel actions

Widgets and variables actions

Miscellaneous actions

Summary

5. Advanced Interactions

Conditions

If-Then-Else

Guided example—conditions and dynamic panels

Step 1: Defining the interaction

Step 2: Constructing Wireframe

Step 3: Setting the first condition

Step 4: Adding the first interaction

Step 5: Completing the interaction

The Condition Builder

Guided example—multiple conditions

Step 1: Defining the interaction

Step 2: Constructing Wireframe

Step 3: Interaction tweaks

Step 4: Evaluating multiple conditions

Satisfy all or any

Step 5: Final conditional touches

Troubleshooting conditions

Raised events

Guided example

Step 1: Creating a raised event on the master

Step 2: Applying interaction to raised events on a page

Nested masters: Amplifying the raised event

Variables

Guided example—creating context with variables

Step 1: Defining the interaction

Step 2: Construction considerations: Dynamic panel or pages?

Step 3: Adjusting existing conditions

Step 4: Variables and the order of actions

Step 5a: Setting variables (and possible snags)

Step 5b: Setting and initializing variables

Initializing, passing, and resetting variables

Step 6: Using variable values to determine appropriate cases

Variable types

Global variables

Axure's built-in variable

Create your own variables

Special variables

Usage examples

Local variables and functions

Naming variables

How variables can help in usability testing

Guided example—contextual usability testing

Pros and cons of using variables

Tips and techniques from the experts

Hiding and showing list elements, by Jeff Harrison

The approach

Step 1: Creating the row template

Step 2: Moving rows together

Step 3: Repeating as desired

Step 4: Adding controls

Keyboard Shortcuts by Loren Baxter

High-level Interaction

Detailed steps

Notes

Axure tricks by Fred Beecher

Trick 1: Debugging your Logic

Trick 2: Passing variable values between pages

Trick 3: Hidden link to clear variables

Trick 4: Text fields masquerading as text pa...