Tag: aea

Senseless waste of asterisks… Avis used an asterisk to denote optional fields. This means that there is a lot of baggage that comes with an asterixk. Somewhere this symbol got meaning, it’s not in the bible!

We can control when something goes from unintuitive to intuitive.

A design is intuitive (although technically and grammatically speaking that is false).

An intuitive design is when the user is focused on their objective.

Simplest site online; haynet, need hay and have hay. Unclear objectives.

Intuitive Design is Invisible. you only notice it when there is something wrong with it. Like the AC in the room, it’s only notices when there is a problem with it. It’s an issue of focus.

Lytro gives focus shift to the users.

We shouldn’t force users to focus on things which they don’t choose to.

Property #1 of intuitive design: Clear Focus.

Kittens die when marketing people win.

Keep focus on the users objective and not on the interface.

Magic Escalator of Acquired Knowledge: zero knowledge at bottom, full knowledge at top. Positions at current knowledge and target knowledge show a knowledge gap. To make a site intuitive we put current and target knowledge as close as possible. An intuitive design is when current knowledge = target knowledge. We can either train people to increase their current knowledge, or we can simplify the target knowledge. Teaching examples: like facebook timeline introduction, google apps update with walkthroughs. Simplify examples: craigslist, umbrella today.

Things with a large knowledge gap that we must use we tend to hate, and when use is voluntary we avoid. Things with a smaller knowledge gap and required are tolerated, and when use is voluntary we are cautious. If the knowledge gap is small enough users love it and use it! Making things usable lets users enjoy using it and they like us!

With a million visitors and a 1.6% conversion rate all purchases. 1 foot = 16,000 Visitors. The customers are the 1.6% that convert! Don’t alienate customers! Don’t destroy current users’ current knowledge, that’s like sending our best customers back down the escalator. Learning a system is an investment and people hate to relearn. Subtle changes doesn’t throw away current knowledge.

Always keep the focus on the users’ objective. Don’t distract with design changes.

Property #2: Map design to user objectives

See price in cart – on online stores is not a trick to get people to buy more. It’s a law they have to abide with thanks to the FTC.

Hipmunk flights drawn on chart and you can sort by agony. Different presentation of flight data, makes the shopping choice much more intuitive.

The medium of design is behavior.

Core skills of user experience (Intuitive): Interaction design, visual design, user research, copy writing, information architecture…

Users only see Local – local links. Users don’t pay attention to global links.

Best way to do user testing, watch people. Watch people. You find out simple and obvious things by watching users using the site.

Property #3: Forewarning

Shopping cart showing shipping before cc input is critical.

“More”, “previous” and “next” links are noise, especially when you come in at the middle. It makes everything out of context.

Pull to refresh: low target knowledge, no current knowledge. Not intuitive – socially transmitted functionality. STF.

Property #4: Understanding of Convention

Key functions enter vs shift enter, tabbing order, google apps:auto-saving.

Convention of proximity: username and password and login button should all be close together.

Understand which conventions users will expect. Techniques for understanding: filed visits, usability tests, paper prototype, Handbook of Usability Testing, Paper Prototyping.

The iPhone changed our industry in 2007: first mobile to have a desktop class web browser and it made people start using their mobile phones as computers!

All apps other than apple provided ones were web browser apps. Most of the first apps were branded web browsers. No real difference between using mobile site or mobile app.

Now companies are asking (like they did in 2000, about a website), “Do we need a website?”

Instagram has no website, just an iOS app.

web != HTML, browsers the web, the code/HTML and native interface are all current services.

When is an app not the answer: content sites, low budget, prototypes, breadth audience.
When is a website not enough: hardware access (native access comes first, javascript coming but years out), software limitations (fullscreen, background processing), data limitations (address book, calendar, media), connectivity (offline access isn’t production ready), practical size constraints.

A website is not always enough.

People are finding apps first on their device in the store and not coming from the web. Websites aren’t promoted in the app store.

Downsides: app stores are closed gate keepers. 30% commissions taken by the app store. Reviews are not respond-able and not gauged for quality or even comprehend-ability, like comments we can’t moderate. Payments.

On the web payments are hard, so we’re using ads. For apps, payment is actually easier than ads.

user-generated content – horrible phrase vs author writes a story.

Monetizations matters, considering “users” as customers we can start serving the customer rather than the ad vendors.

Apps are not inclusive, we need to develop an app for every device. And that limits the audience to those who have that device.

Design considerations, style tips: use standard controls where possible, integrate webview seamlessly,

Native to one platform you just build for that platform and don’t have to worry about browser inconsistencies.

Tips:
Mind your encoding: utf-8
When loading content set bg to transparent to avoid white flash
show a progress spinner, hide the uiwebview when remote content loads
consider disabling scrolling in secondary or minor uiwebviews
disable long-tap link menu (add value to standard behaviors)
disable text auto-resizing and text zooming
control orizontal oerflow to prevent unintended scrolling
consider advanced text rendering (carefully – t can get pretty slow)
consider auto hyphenation (small performance cost)
consider disabling data detection (phone numbers, emails, etc)
load local resources with relative file urls, or use data urls
communicating between environments – native code to webview javascript.
consider listening for gestures in js

Why does all this stuff matter?
Able to learn it one thing at a time: because things start slow and modules are added over time. It’s easier to keep up with changes than it is to learn everything.
HTML, Web Design and Apps are all in the same eco-system and there is some overlap. Best to learn more about apps NOW, as it starts than try to catch up later.

MASS MEDIA (in waves)
Print, Recordings, Cinema, Radio, Television, Internet, Mobile

Mobile is the new Mass Media

It certainly is mass and massive. More mobile devices (by far) every day than babies born on the planet. Mobile devices are eating into our personal computing shares.

New waves of mobile media eat all previous media waves. Mobile has indeed eaten all previous forms.

A new form of media always introduces new features or characteristics! Always on, portable, digital, social, augmented reality… the list goes on.

We have to recognize that the mobile is not a desktop. Our first inclinations are to copy what we did before (in the last wave). It takes a while to shed old paradigms.

StumbleUpon has been huge on mobile (as well as Kayak). They are doing a complete relaunch based on what they’ve learned on mobile.

Take what we know on the desktop web (today) and adapt it and optimize it for the mobile (today) and move forward (tomorrow).

Logins

passwords – forgotten passwords are rarely shown on mobile login pages.
Don’t remove things that are critical.
Use input and types and attributes. (autocapitalize, autocomplete)
show passwords – “Masking passwords doesn’t even increase security, but it does cost you business due to login failures.” -Jakob Nielsen
input masks
save passwords and let users login without a password (use single sign-on via: facebook, twitter…)

Set default to smarter option (like organ donors).

Adapt and optimize what we were doing yesterday and apply it to today. We can even make these things apply to yesterday!

Think to tomorrow: touch gestures, facial recognition, sms authentication
Step back and think about problems we’ve already solved. But use new techniques that have evolved since we’ve come up with the standard solutions we are regurgitation constantly without rethinking the problem. We can do much better now, but we’re so used to throwing the same solution at the same problem there is no more thinking about it. We don’t need to inherit the same issues we already have, let’s solve them by rethinking the original solution.

Why bother?
This new mobile mass media is always on, always on them and available at point of inspiration!

Checkout

3 of 4 carts were abandoned in 2011!
We should reduce effort:
Removing unnecessary questions
Keep people on the keyboard, combine fields (first name + last name = full name)
Hide irrelevant controls (until they need them)
Set input types( type=tel ) use input masks, ignore bad characters. Credit card use input-type=tel for the numberpad.
Keep people on their keys

Check out square to see the improved cc fields.

Progressive Enhancements – use what best fits the device that’s being used.

Checkout for the futures:
Contacts API, Location Detection, Self-checkout and Scanning

Korean grocery shopping in the subway! Tesco, scan qr codes and groceries are delivered automatically.

Mobile is a massive new medium! It forces us to adapt and optimize our solutions and moves us towards the future. We should push for better device apis! Let’s agitate the blockers and the bug guys: Apple and Google. PhoneGap lets us do all these things already using existing standards! Tomorrow Today.

Mobile and touch should be revolutionizing design and user experience.

We don’t want to touch a tiny link or button. Back button is just stupid. Fitz’s Law, make things fat proximal targets for easy touching.

People are lazy, let’s as designers LET people be lazy! Maybe even use the whole screen as your control.

Eliminate buttons if we can! Buttons aren’t evil, they just aren’t as relevant for touch. Gestures are the keyboard shortcuts of touch!

Big screens invite big gestures, don’t make people hit little specific buttons or links. Buttons are a HACK. Light switches are not intuitive, they are a learned behavior, an inspired hack introducing a middle man.

We don’t need an abstraction layer for uI controls. We can directly manipulate the object by touch.

The new Windows OS is leaning this way! Twitter iPad app is doing this. Rather than a back button or a UI, we just swipe our way through content.

The web sucks as coding gestures and is like the red-headed stepchild of interaction design. It trails behind proprietary technology. Flash helps bring standards, but we’re still waiting. But we can speed that process and push standards and agitating for more and better. We need to push for support for gestures (for now all we have is touchstart, touchmove and touchend: which aren’t very helpful and not widely supported).

The gesture conventions are tap and swipe. Plus there’s the emulator layer of the browser. As a community we need to figure out together what conventions there are and how to best apply them. It’s not easy to go beyone simple taps and swipes. jQuery mobile and Sencha touch are libraries that give us more events – these are really tuned with web-kit and are pretty big frameworks meant for creating html5 apps along the lines of PhoneGap. Touchy.js – more lightweight, but there are still some big holes.

http://bit.ly/ikeatouch – Direct interaction with the content itself.
http://bit.ly/ios-clear – Playing with objects as the interface.
Ipad App Touchup – lets you paint patters on images, but rather than adjusting brush size you adjust canvas size and the brush is always the size of your finger.

For mobile: clarity trumps density. The more features and controls we have, the more things get in the way. The more power we give people sometimes the more paralyzed they become. Swiss army giant pocket knife.

Gestures are invisible. So how do you find out (or instruct) about these controls – Finding what you can’t see. Create realistic user interfaces, with a little help, people will learn to work interfaces. Nearly everything has to be learned or taught: snooze alarm, qwerty keyboard. We always start with a physical reference. Social signifiers or cultural: who knows the salt vs pepper shakers? The only thing that matters is what the person that filled them thinks! Cut out the middle men and let the content be the control. Clear salt and pepper shakers! Let people interact with the content and not the buttons.

The medium is the message, The message is the medium.

Give obvious visual cues. Instructions are making things harder, nobody reads the manual!
How to use a magazine
How to use a book

It needs to become intuitive. Nature doesn’t have instructions, look at a toddler, we figure things out as we go. Use a book metaphor, but don’t break conventions. EMBRACE the metaphor! Don’t make me tap buttons if the interface makes me think otherwise. There is a digital advantage to random access navigation.

Toddlers are learning how to use iPads faster than adults. We’ve learned incorrect gestures and are not used to thinking about them. Approach apps and designs as we’re building them for children. Video games are great at teaching you how to use the interface, not with a manual, but by drawing you through the experience by:

• coaching (with active discovery) – we learn by doing. Things that move can perhaps be moved by users.
• leveling up – when you learn something, it moves on, demonstrate gradual progressive controls
• power ups – efficiencies in the hands of experts. keyboard shortcuts. achievement based unlock tools by learning

We should be generously talking to each other about how were trying to use our gestures. It’s exciting to be involved in inventing the futures of how we’ll be using tools, be involved in the discussion. Have empathy for the users.

Grep to for analyze css.

CSS duplication is a web-wide problem.

Started helping facebook optimize thier site and they had 1.9MB of css loading. The same color showing up hundreds of times. Many many color statements and declarations.

• !important declarations get dangerous. Sites found to have over 500 !important declarations!
• float is a serious problem when there are a lot of them. It’s better to use some sort of abstraction rather than floating everything for layout.
• font-size: there should not be a need for more than half a dozen size declarations, use abstraction!

insanity: doing the same thing over and over and expecting different results.

We all have this problem of duplication. CSS (like JS) will let you do anything you want (even if it’s stupid). But we don’t have to do stupid things!

New Best practices

• Pixels for fonts: became frowned on with ie6, but all modern browsers use pixels, ems and percentages just fine. Why not avoid percentage and ems because they have significant drawbacks and compounding effects.
• Adding extra syntax/markup: separations of concerns – make functionality overlap as little as possible. Solve one problem at a time and use extra mark-up judiciously (don’t go nuts with dives, but also don’t strip out too much and introduce bugs).
• Semantics: class names and ids are not usually read by end users, so let’s make sure class names and ids work well for developers. More is not always better. Create abstractions that solve problems one time. Don’t couple CSS too tightly to the content or the display. DRY (Don’t Repeat Yourself – Every piece of knowledge must have a single, unambiguous, authoritative representation within a system).
  Media block (like a SLAT in dan’s talk). Separate structure from chrome (design). May have some extra css class names or divs, but it will cut html and css overall.
• Classitis: use specificity to accurately target elements. Class order in attribute doesn’t matter, but order in the actually cascade. Specificity grows over time and you end up coding via firebug. !important is like nuclear trump in CSS. Avoid the nulcear option: keep specificity low: avoid IDs, inline styles, !important, and very complex selectors. Apply classes to the element we are trying to affect (not to a parent node). Use class “h6” along with h3 elements for visual and code semantics to play nicely.

Great developers can build amazing things if we move worst-best practices out of our way.

Resources:
oocss – join the oocss google group
csslint.net

Cormorant trained to fish for the fishermen. The fishermen tie bands around the birds necks that are. Fishermen fish at night, using lamps they attract bugs, which attract fish, and the cormorant get to fish but cant swallow them and the fishermen take the fish.

Browser vendors are promising us new CSS tools, but don’t actually let us use them. It’s a big tease! Cormorinths are either fish in the hand, diving for fish or still sitting on the shore. A lot of really cool stuff we’ve just been teased with and told we can’t quite use yet.

(SASS and LESS will any and all prefixes.)

• Transforms: Go for them right now! Widely supported and mainly just for decorations.
• Transitions: Go for them now! Basically event driven, if the browser doesn’t support them they don’t work and no one needs to know. No reason not to use this stuff, it’s decoration.
• Animations: These have some issues still. Animations are constant, and the problem is only webkit supported them until recently but then the working group took it went back to the drawing board. Still in production.
• Multicolumn: Not fully supported yet. Some browsers support the main idea, but none of the details like gutters.
• Grid Layout: Hang elements off of specified grid lines for layout. Only supported by IE10, but not bug free…
• Exclusions: define an area that content will flow around. Not locked to rectangular objects (can use alpha channels or svg shapes to define areas).
• Regions: Define text-flow from one area to another. Requires document structures we are not used to, using empty structure for the browser to implement.
• Combinations: Using all or any of these elements together.
• Flexible Boxes: If you have a use case, then go for it. But they are going to be changing the spec for it. It will be a different spec though, so it shouldn’t break.
• Scoped CSS: using a style but limiting it’s scope to the parent element that imports it.
• Calc: Really nice, but for now rely on preprocessors. Drawback is that it’s only on first render, if element is updated via scripting
• Masks, text-stroke, box-reflection: webkit only! And not looking like they will spread.
• Paged Media:
• Hyphenation: use now with a good polyfill. (Polyfill – spackeling paste to fill in cracks and crevices – nothing to do with polygons and fills)
• Gradients: Borderline shore and dive… Really cool, webkit and gecko have totally different syntaxes (to the degree of english and chinese), fun to look at, but a torture to declare. Calling it now, gradients will be web 3.0, rounded-corders was 2.0
• Border Image: border is defined by slicing an image into sprites and applying it to the border (and even background image). It is supported in a number of browsers though, so use it but don’t depend absolutely on it.
• Border-radius: fish! Use now and go crazy with it.
• Web fonts: use it now, but use it wisely (refer to Jake’s talk).

But what can we do about it? Can we prod the working group to move things along.

First thing to do is experiment with the properties! You spread the cool effects, second you find crazy unexpected bugs. Use html5please.us as a guide (even though he disarees with some of their points and they talk about css3, js and stuff as if it is html5). Browsersupport.net documents which browsers and versions of those browsers support css3 properties. CSS3.info (subscribe to the rss to be kept in the loop, as well as the css3 working group). Even subscribe to the [email protected] emails list (and f you’re like me, I know I am, set up a filter and archive it and then poke into it when you have some time. Take it even further and join the w3c with a reduced membership fee for startups (advantage is that you can send a representative to the working group). Also, blog about it! Document what you discover, write it up and publish it, tell others what you’ve written maybe even in the mailing list. CSS samurai documented top 10 failings in each browser and each one got fixed eventually.

We didn’t get here all at once, it’s been here a little there a little. But we are progressing and eventually will get somewhere good. Every day, week and month more support is coming.

2011 was a year to step back and learn something new. What else other than the banjo! Banjos are very misunderstood. Learning new things helps us to become better at things we already do. The process of learning can be applied to things we know to break it apart and we can better ourselves.

1. Imitation – LEARN – view source of greats
2. Repetition – DO – And do until it reaches second nature – build repetitive patterns
3. Innovation – apply your own creativity – reinterpret – stylize – own

Frameworks are great tools, but they are learning tools. A good craftsman builds their own tools!

Pears

http://pea.rs/ – common patters of mark-up & styles
-an open source wordpress theme to allow anyone to set up their own library of repetitive patterns.

Let’s be semanticaly correct.

Examples: HTML5 – placeholders, roles (ARIA landmark roles – Jeremy Keith of adactico.com)

stronger css selectors rather than more classes in css. (nth-child() in place of even, odd, alt, classes)

Slats – are blocks of content usually containing an image (thumbnail), title and description and even more optional info(date, tags, etc). They are often teasers of more content that should click through.

Breaking things into patterns you can solve small problems w big impact.

Overview of SASS (I agree with Dan and have been hesitant to implement CSS preprocessors)
Love the idea of preprocessors for CSS

Earl Scruggs revolutionized banjo playing with a new style (Flint Hill Special)
Bluegrass killed the banjo (arguable) by making it too hard for average people to play the new cooler styles.

One reason why CSS didn’t have many of these SASS and LESS features to begin with was the creators didn’t want to make it a complicated language. If you make something too powerful it can get too overly complex and people don’t use it.

There is a pride also in the handcraftedness of the source code. We like tools that plug holes, but don’t mess with our craft. But the benefits of using CSS preprocessors outweighs these nits. It’s easy to install:

$ gem install sass

(There are also tools that can help: Scout) It’s easy to watch a sass file and have it automatically recompile a CSS file on save.

watch $ sass ...

This is beautiful for those who follow the DRY mantra: Don’t Repeat Yourself!

CSS Preprocessors give us: variables, functions (mixins), inline media queries.

Respond or Adapt! Responsive Web Design

Dribbble set with a single breakpoint at 500 in which it makes the ayout of the site fluid. This is so we don’t have to consider the plethora of mobile devices using various sizes around the same.

We should let our content dictate our breakpoints rather than the popular devices dictating the breakpoints. Avoid display:none; give better options or if it’s really not needed get rd of it everywhere.

1. Embrace Patters
2. Solve Small Problems
3. DIY Frameworks
4. http://pea.rs