Motivation and hiring

November 16th, 2010

I don’t think I ever wrote about motivation much here even though it’s one of my favorite subjects and was also the main topic of my thesis. Recently I’ve been thinking about it quite a lot again and I’ve come to the conclusion that it’s very important to use it to hire the right person.

Back to the beginning. There are loads of theories on motivation and most of them just cover different aspects and mostly they can all live together. One of the aspects of motivation is where it comes from. That gives us intrinsic motivation and extrinsic motivation. Obviously it’s not a boolean thing as any individual sits on a line between the extremes. And there’s also the matter of having a different source of motivation for different things. Let’s not get into that.

Intrinsic motivation

Let me quote Wikipedia on this:

Intrinsic motivation refers to motivation that is driven by an interest or enjoyment in the task itself, and exists within the individual rather than relying on any external pressure.

We are motivated by the fact that we’re getting something done and by the feeling we get ourselves when we’re done. We’re not in it so someone can tell us we did a good job. We don’t really care. A friend of mine once said: “It’s for me. If somebody else likes it – great.” We like to think that the more we get into the subject, the better we’ll be at it and the better the result. In other words no relying on luck, no shortcuts, no marketing/selling, no subpar stuff. Because of all this we don’t like when others interfere with stuff we’re responsible for.

Extrinsic motivation

Another quote from Wikipedia:

Common extrinsic motivations are rewards like money and grades, coercion and threat of punishment. Competition is in general extrinsic because it encourages the performer to win and beat others, not to enjoy the intrinsic rewards of the activity.

These people often need to be “managed” to give them the sense of direction and success and are in that way more demanding. They also need more information about what is going on and might see the successes of their co-workers as their own and be empowered by them.

Who to hire?

You might want to hire intrinsically motivated people when you don’t have the management layers to keep them motivated or you just don’t have time to do that. On the other hand it’s very hard to keep them motivated when all the fun work is gone and thus tend to either switch tasks/assignments or try to over-explore/discover. These two reasons are also why some people want to hire intrinsically motivated employees only to later regret it as they can’t motivate them anymore or don’t know how.

Hiring extrinsically motivated people might be better for cases where you can manage them properly as they might feel lost without guidance. They are somewhat easier to motivate as you have a lot more ways to do it – sometimes even just a public pat on the back suffices. They are surely a better choice for a company in an established market as they thrive on beating the competition. If you have an “employee of the month” you should hire extrinsically motivated people.

I think it’s very important to hire a homogenous team motivation-wise. An extrinsically motivated manager might have a problem motivating an intrinsically employee and the employee won’t get why his extrinsically motivated colleague is bummed that he wasn’t complimented on the great work last week.

The intrinsic problem

We intrinsically motivated have a problem. Even though that extrinsically motivated people can internalize motivation when it matches their values and beliefs it is much more common for somewhat extrinsically motivated people to become more and more extrinsic with time due to the Overjustification effect. As that means that their number will go up with time, most of us are used to just getting in to solve the problems and then get out. Somewhat ironic that it sounds like a mercenary.

HTML Lint

August 30th, 2010

From Lint Instructions:

HTML Lint is a tool that makes sure your code looks good. While XHTML was very strict with syntax HTML 5 is more lenient like previous versions of HTML, which means keeping consistent code styles will become more difficult. Validating is not good enough anymore.

HTML Lint is under constant development. If you find a bug, report it on Twitter.

It started in Seattle, at An Event Apart. Jeremy Keith said in his presentation that validation for HTML5 doesn’t make much sense anymore and that there should be a Lint tool. I started thinking about it and after lunch I asked Jeremy what options he wanted in it. I added some of my own and made the first version of it flying to Phoenix (going to IA Summit) and then fixed it flying back to Ljubljana.

We released the first version soon and updated it with a new design a few days ago. I’ve been putting the update off as I had a few other projects going on, but Jeremy mentioned it at Drupalcon and Remy pointed his htmllint.com to it and tweeted about it. So it had to be done.

HTML Lint was coded in Python by MMM, which consists of me (Marko Mrdjenovič) and Marko Samastur. The design for it was done by Sara Tušar Suhadolc. The source code should be available soon.

The Cross-Origin Request Sharing (CORS) knot

August 3rd, 2010

As a developer for a company that does a lot of cross-domain posting I was happy to see CORS finally happening. I’ve authored jQuery.windowName plug-in to add support for cross-domain posting in the past and this was my way out – no more hacks as browser support for CORS grows.

Yeah right.

CORS is supported on XMLHttpRequest object in Gecko and Webkit. You just request something on a different domain, and if the response has the right header with the right value you get the data. In IE you have to use a new object called XDomainRequest which is somewhat similar to XMLHttpRequest, but without readystate, onreadystate event handler and basically any header getters/setters.

Sounds ok and when I first tried it I was quite happy with how it worked. But unfortunately nothing is that simple in the land of browsers. When it fails, it’s a whole new game…

Gecko (Firefox)

Same domain request:
  • 200 response: xhr = {status: 200, statusText: ‘OK’}
  • 304 response: xhr = {status: 304, statusText: ‘Not Modified’}
Cross domain request with proper headers:
  • 200 response: xhr = {status: 200, statusText: ‘OK’}
  • 304 response: xhr = {status: 0, statusText: ‘Not Modified’}
Cross domain request without proper headers:
  • 200 response: xhr = {status: 0, statusText: ‘OK’}
  • 304 response: xhr = {status: 0, statusText: ‘Not Modified’}

Webkit (Safari, Chrome)

Same domain request:
  • 200 response: xhr = {status: 200, statusText: ‘OK’}
  • 304 response: xhr = {status: 304, statusText: ‘Not Modified’}
Cross domain request with proper headers:
  • 200 response: xhr = {status: 200, statusText: ‘OK’}
  • 304 response: xhr = {status: 304, statusText: ‘Not Modified’}
Cross domain request without proper headers:
  • 200 response: xhr = {status: 0, statusText: ”}
  • 304 response: xhr = {status: 0, statusText: ”}

IE

Same domain requests made with XMLHttpRequest, cross domain requests made with XDomainRequest.

Same domain request:
  • 200 response: xhr = {status: 200, statusText: ‘OK’}
  • 304 response: xhr = {status: 304, statusText: ‘Not Modified’}
Cross domain request with proper headers:
  • 200 response: onload invoked
  • 304 response: onload with cache, onerror otherwise
Cross domain request without proper headers:
  • 200 response: onerror invoked
  • 304 response: onerror invoked

Where’s the knot?

The problem with this is the lack of error handling. Firefox will return status 0 on all errors, but will indicate what the response was with statusText. It will also return 0 on a 304 response, which is a bit weird. Webkit on the other hand only returns status 0 on failed requests, but without telling you what’s wrong. You get the same error when a preflight request fails, a 500 error on the server or the real request fails. IE with its own separate XDomainRequest implementation simplifies this two handlers – onload and onerror. Unfortunately it raises an onerror request when a 304 is returned on empty cache.

jQuery issues

If you’re working with jQuery (and possibly other libraries) you’re in for a treat. Opera 9.5 falsely reports status = 0 when a HTTP status 304 is returned from the server. For this reason jQuery treats status === 0 as a successful request. Thus you have no way of knowing whether your request was a success or a failure.

Untying the knot

If you intend to use jQuery’s built-in methods you’ll need to do your own bookkeeping:

  1. Know when a request is a CORS request
  2. Wait for complete event
  3. If data is empty trigger error handling

For this to work you obviously always need some data. If empty data is valid you’re screwed.

Easy way out

You might have noticed before that I made a jQuery.windowName plugin. It still has the same name, but now also supports CORS requests and does some of the CORS related bookkeeping. As the latest version is still in testing you can get it directly at http://friedcell.net/js/jQuery.windowName/jQuery.windowName.plugin.1.0.0.js (test page).

Enhanced by Zemanta

Blogging on the iPad

June 15th, 2010

I wrote the previous post on the iPad in the WordPress app and I was forced to finish it in the browser. Here’s why:

  1. Writing HTML is very hard on the iPad due to extensive keyboard switching. Opening tags are hard, but closing tags are even harder (switch to extended for <, back to symbols for /, back to normal for the tag name and then to extended for >).
  2. I’m missing the spell checking feature I have in my Firefox, because I usually have the iPad native checker off as I write lots of stuff in Slovenian.
  3. I like adding some links automatically with Zemanta and you don’t get that in the native app.

While writing the first version of this post I also found another error – it seems that the WordPress iPad app doesn’t like &lt; or &gt; inside posts, so actually writing an HTML tag like this <a> is not possible (it crashes the app immediately).

So it seems I’ll still mostly be using the iPad for content consumption and chitchat and not content creation. And possibly scribbling down ideas.

Enhanced by Zemanta

Login code pattern

June 15th, 2010

When coding a login interface it’s common to follow this pattern:

  1. POST data to a script that checks it and sets appropriate cookies
  2. On success redirect to the previous (or some other) page
  3. On error show that error or redirect to an error page

You do this so that users don’t get the annoying “resend data” pop-up if/when they reload the destination page. On the other hand this pattern exposes a usability issue when login data is correct but cookies are turned off.

For some reason my cookies were disabled today. That means that logging in to Twitter (that uses the previously described pattern) looked a bit weird. I’d log in, get redirected and end up on the home page again. Same thing happened on Mozilla Addons page. The very definition of recursion.

When I finally figured it out, I immediately thought of a solution. When you redirect from the post add something to the URL – that way the redirected page can check if you’re actually logged in and alert you if you’re not.

Now this has a few problems of its own:

  1. It exposes that you have an account on a specific service that can be detected with history sniffing.
  2. If you create a user based URL to circumvent the previous issue you might leak user information.
  3. If you reload the destination page after session expired you’ll get an alert that might be wrong itself (you would have to implement some server-side logic that checks if the session has just started).

With all this in mind I still think that redirecting to a different URL is better than leaving users without any information (no matter how uncommon having disabled cookies is).

How do YOU solve this?

Enhanced by Zemanta

An Event Apart Seattle review – day 1

June 2nd, 2010
An Event Apart Seattle
Image by Heather L via Flickr

“This is your pilot speaking. We’ve been notified that the passenger bridge has a flat tire.” were the first few words after landing in Chicago, the third airport of the day. I left Ljubljana at 7:15 CEST towards Amsterdam, switched planes and continued towards Chicago. Fortunately the issue with the gates was small enough not to endanger my connection for the last leg – to Seattle, where I landed around 16:15 PST (around 18 hours after taking off from Ljubljana).

I came to Seattle to attend An Event Apart, a conference I wanted to attend since it was first announced. Meeting people like Jeffrey Zeldman and Eric Meyer and learning from them is just amazing. But first I needed to get to the hotel in downtown Seattle and get some sleep.

After a really long day the light rail ride from the Sea-Tac airport to downtown Seattle was really amazing. Going through the suburbs, enjoying the displays of American culture – the highways, the trucks, the architecture, the people. There were only a few of us on the train at the first stop, but at the next stop loads of people got on wearing bright green shirts, scarfs and even a few kids with their faces painted green/blue – fans of Seattle Sounders FC. I thought to myself – nah, it can’t be soccer.

As I arrived a day early I had a day to spare to see the city. I woke up late and then visited The Space Needle – amazing views even in cloudy weather. I didn’t take the old-school monorail built for the world fair in 1962 thinking I’ll do that some other day. After registering at the wonderful Bell Conference Center (thanks to Marci for resolving the issues and sorry I woke you up Gašper) I walked through town to the Pike Place Market and to the high street stores – and wandered into a huge Anime convention (Sakura-Con) and a bunch of kids (not even teenagers?) wearing totally inappropriate clothes.

The day ended with a karaoke meet-up set up by Jeff Croft. I met Mike Davidson of the Newsvine fame (thanks for the beer!) and I heard Andy Clarke and Jeremy Keith sing Ace of Spades together.

The conference started on Monday with breakfast – a really good one. And then two days of talks and an additional day of workshops. I’ll review them in different depth.

Jeffrey Zeldman – Put Your Worst Foot Forward

I wanted to see Jeffrey talk for some time now. I also got to meet him just before the conference started which made me want to see this even more as he’s a really friendly guy with years of experience to share. And the talk proved to be all that and more. Explaining his mistakes from the past and the ways he is solving them – teaching what to do with anti-patterns (to quote Jeremy Keith) was really effective and I think we were all nodding as it seems we all do the same mistakes.

The checklist

  1. Know before you go.
  2. Keep expectations on track and in sync.
  3. Constantly course-correct.
  4. Tell the TRUTH.
  5. Phrase it from the client’s/boss’s point of view.
  6. Report bad news before the client/boss notices it.
  7. Have a recovery plan.
  8. Apologize-but never denigrate yourself or your team.
  9. Have an exit strategy.
  10. Know when to quit.

Takeaways

Working with clients is a long distance relationship – away from sight, away from heart. You need to put more energy into syncing and you need to make sure you see things with their eyes. And as in any relationship – you need to know when to leave.

Nicole Sullivan – Object Oriented CSS

Nicole used to work for Yahoo! and recently helped Facebook optimize their stylesheets, so you might say she has some experience in building and maintaining CSS systems. But unfortunately it also means that a lot of us cannot relate to some stuff she is saying. One of the first thoughts I had was that she might be a good person to write the “CSS – The Good Parts” – she even quoted Douglas Crockford in her presentation.

Controversial

There were a few points that I couldn’t agree with when she said them and decided that I will think about them later. I’m not saying they’re bad practice, I just don’t think they’re good advice for most of us.

  1. Don’t use specificity was one of the things that seem like throwing away a really powerful tool because some people can’t handle the power. I could probably agree with this in big systems, but it sounds like one of the reasons to adopt Java – it’s easy for beginners to start doing productive stuff and hard for them to screw things up.
  2. Don’t use .class1.class2 as that causes all sorts of cross-browser issues. I would classify this as good stuff but it seems only IE6 is affected. So I couldn’t care less…
  3. Hacks shouldn’t change specificity as you’re not using specificity at all. That means that Modernizr and all other tools that add a class to the HTML/body elements are out of the question. The solution – using _property:value; – was something I don’t feel good about – using such invalid hacks just seems wrong.
  4. To define headers use h1, .h1 {} and in HTML use <h2 class=”h1″>…</h2> if necessary. That just seems wrong even though I agree that reusing styles is important.
  5. Avoid specifying location when targeting elements. When you do that moving an element into a different context loses the styles.

Good stuff

This list is what I think can mostly be used today for most of the people writing CSS. It is not a set of rules to abide in every case, but it should be your main modus operandi.

  1. Reuse code as much as possible. If you’re copy pasting, you’re doing it wrong. One of the ways to do this is by following the second rule.
  2. Don’t use ids, inline styles and !important to write easily applicable code. You should not write location specific code. Don’t use .sidebar ul, but rather add a class (eg. sidenav) to that ul and use .sidenav for the rule. Smaller CSS yes, but it will also get you bigger HTML (and classitis?).
  3. Think in modules and provide styles that are easily reusable by just using a class name in HTML. Only elements that are strictly bound to modules should have location specific selectors (but with .class, not #id).
  4. Put defaults into .class and use elm.class to apply specifics. Many elements can have .error – and all errors should have a similar look, whether they’re divs, lists or paragraphs.

Wish-list

  1. Variables are something a lot of people want. What I want is for them to be simple enough that people can’t abuse them to make CSS a programming language. The proposed syntax:
    • To set the variable: @variables hex {myblue:#006;}
    • To access the variable a {color:hex.myblue;}
  2. Prototypes are a really good way of providing defaults to a lot of elements at once and gets rid of rules that have many comma-delimited selectors. The proposed syntax:
    • Set a prototype with allowed child nodes: @prototype .box {margin:10px;children:b,.inner;}
    • Add styles to child nodes: .box .inner {position:relative;}
    • Use a prototype: .weatherBox {extends:.box;}
    • Under the hood this translates to: @prototype .box, .weatherBox {…} .box .inner, .weatherBox .inner {…} .weatherBox {…}
    • Also allows checking code: .leftCol .inner {color:red;} is invalid as .inner is part of .box prototype and .leftCol does not extend it
  3. Mix-ins were skipped in the presentation as she was running out of time. You can think of them as small pieces of repeatable code that is only set in one place and used in others. Syntax:
    • Set a mixin: @mixin .clearfix {zoom:1}
    • Any selector that matches the mixin selector modifies it: .clearfix:after {content:”.”;display:block;height:0;clear:both;visibility:hidden;}
    • Include a mixin: .line {include:.clearfix;}
  4. Prototype sub-nodes were also skipped. They seem to allow calculations based on values defined in different sub-nodes of prototypes – they’re not meant to access computed style:
    • Use calculations: .box .bottom {height:5px;} .box .bl {height:10px;margin-top:.bl.height-.bottom.height;}

Some of these changes will require us to write code for new and old browsers independently or to write a “compiler” that will compile code for older browsers. Is there one already written?

Takeaways

Building a CSS system means thinking about the selectors (and not the properties) and Nicole probably knows more than anyone else on that subject (to make you feel more comfortable, Jeremy Keith of Clearleft said they arrived to the same conclusion independently). Another, probably even more important takeaway is that you should think about flexible modules – sometimes stuff is more similar that it might seem at first. If you write CSS for a module that supports variations you’ll write less code that will apply faster and your visitors will be happy. If you want to look into an Object oriented CSS framework – check Nicole’s project OOCSS project at GitHub.

Dan Cederholm – The CSS3 Experience

Dan told us that we can and should use CSS3 now in non-critical areas such as experience, visual rewards, feedback and movement for users with the latest & greatest browsers. Not so much progressive enhancement as progressive enrichment.

Some ideas for use of CSS3:

  • Hover on items with RGBa background, a text-shadow and a border-radius with a transition (Sam Brown style).
  • Hover with opacity change. Create a single image, make it transparent normally and less transparent on hover. With a transition of course.
  • Multiple backgrounds to achieve a Silverback parallax effect.
  • Enriching form elements with a background gradient and border radius.
  • Making form buttons prettier with text-shadow, border-radius, box-shadow and a background gradient. Animate the focus styles.
  • Use scale transform with box-shadow and a transition for hover on images in gallery.
  • Rotation on hover for a single degree with a transition.

Takeaways

You can use CSS3 today, but know what others are missing so they don’t miss critical visual cues. Be subtle with these things or we’ll end back at using transitions to make stuff blink.

Luke Wroblewski – Mobile First!

Web products should be designed for mobile first. (Even if no mobile version is planned.)

Mobile is a big opportunity for growth, but you need to think about different things than when you’re doing web development like:

  • Multiple screen sizes and densities
  • Performance optimization
  • Touch targets, gestures, and actions
  • Location systems
  • Device capabilities

Designing for a smaller screen size will make you focus on core actions. To do that you’ll need to know your users. You should focus on iPhone, not (only) because of its popularity but also because it sets the design expectations very high. It also doesn’t allow any hidden features that hide in menus pressed by buttons – everything needs to be on the interface. When designing you should define device groups, create a default reference design and define rules for content and design adaptation – opt for web standards and a flexible layout. Technically you need to take care that you reduce requests and file size. You should take advantage of HTML5 that allows you to cache things locally and gives you the canvas tag that might sometimes be smarter than loading images. Think outside your web box – less cross browser issues means some new tricks come into play (like data URLs).

The context of using mobile applications is different. It’s not a long time sitting in front of a computer but rather quick bursts of attention everywhere, using mostly just one hand.

Mobile is innovating fast and you should think about the new capabilities to innovate yourself. Touch interfaces mean no hovers, thinking about bigger touch targets and a bunch of gestures that differ from platform to platform. Location information (from GPS, WiFi, cell towers or IP) is almost ubiquitous and can be used for positioning and filtering, but you should not forget other innovations that are less obvious like orientation information, audio & video input and output, compass, push notifications, Bluetooth connections, proximity sensors, ambient light detectors,…

Takeaways

You need to think about mobile because it’s an opportunity for growth, the constraints will give you the focus you need to make a great product and the capabilities will drive innovation in your product. But don’t forget that the design considerations are different.

Aarron Walter – Learning To Love Humans—Emotional Interface Design

There’s a lot of talk about usability of web pages, but is this enough? Usable is just edible. Would you say you go to the restaurant because their food is edible? We have a few options on how to trigger an emotional response to our designs – one of them is giving our sites personality. It’s a platform for emotional response as we like to empathize and personality invites empathy.

People will forgive shortcomings, follow your lead and sing your praises if you reward them with positive emotion.

You can use treats to give users something more. Let users discover new things. It’s the little positive surprises that make us happy.

Takeaways

Usability is not enough, we need to think about designing pleasurable experiences. We need to create an emotional response from our users and make them want to come back.

Jared Spool – Anatomy of a Design Decision

How do we make design decisions and what kind of designs exist? There are a few decision styles:

  1. Unintentional design – when users will put up with whatever we give them and we don’t care about support costs and frustration (think airlines & hotels).
  2. Self design – works great when users are like us and we are our own users (think 37signals).
  3. Genius design – when we have domain knowledge that informs our decisions and we’re solving same design problems repeatedly.
  4. Activity focused design – when we can identify users and record their activities to go beyond our previous experiences.
  5. Experience focused design – when we want to improve our users’ complete experiences, in between specific activities.

There are ways of moving up the chain:

  • “Eat your own dog food” to get from unintentional to self design.
  • Do usability testing to get from self design to genius design.
  • Field studies get you from genius design to activity focused design.
  • Personas & patterns help you get to experience focused design.

There are two fundamentally opposite ways we can make decisions:

  1. Rule-based decisions are based on design books, brand identities and other rules. They don’t allow exceptions and ignore the knowledge of the person deciding.
  2. Informed decisions are based on design patterns and put the person deciding behind the wheel. They are good for handling exceptions.

With this in mind we can look into what is needed to do one or the other:

  1. Dogma
  2. Methodologies
  3. Process
  4. Techniques
  5. Tricks

The first two are typical for rule-based decision making as they rely on a set of rules and don’t require a lot of knowledge from the person deciding. Techniques and tricks on the other hand come with experience and a lot of domain knowledge.

Takeaways

You need to know which decision style you’re using and encourage informed decisions, avoiding rule-based decision making. Techniques and tricks are more effective than methodologies and dogma even though/because they’re harder to come by.

Pete LePage – Help Us Kill IE6

A sponsored talk that didn’t really turn out as bad as some I’ve seen at other conferences (eg. FOWD). Pete presented the history and some IE9 features. He also suggested that we let IE6 users know that they might want to upgrade their browser as Facebook does.

MediaTemple Party

The party was nice – being fashionably late meant that it wasn’t too crowded and that most of the snacks had already gone. I had a brief chat about designing Drupal 7 with Mark Boulton, met Aarron Walter and Petra Gregorová formerly from Slovakia and a police man from Denmark that does web development in spare time. And I grabbed a (mt) beer and a coaster as a souvenir.

Enhanced by Zemanta