12. November, 2013
The article “WORKING IN A WANNABE-AGILE TEAM” points out a common problem in agile: It really exposes you and most people simply are prude.
Unlike many people want to make you believe, they are aware of their own flaws and how much a certain process humiliates them – it’s a skill everyone adopts at an early age, and therefore almost completely subconscious.
Since there is no way to be agile without looking at the team’s issues, the solution is to offer them something else instead.
In my experience, the easiest foot to get into the door is testing. When customers ask for features, ask “How would you know that it’s working correctly? Can you give me an example?” Yay, acceptance tests for free.
People struggling with a piece of code that fails all the time in interesting ways? “How do you know it’s wrong? What would be right? Maybe we could write a piece of code that makes sure it stays right from now on?” Yay, unit testing.
“Can you write a test?” “You can’t test that!” “…. You wrote software that can’t be tested? Seriously?” “… No, of course you could test it but …”
The best part: It focuses on solutions. When suggesting tests, no one can get into the blame game. Everyone can get involved. Customers, managers, developers, everyone understands tests. And they offer the most value for the least investment.
When people have started testing, they become interested in other things as well: Agile planning. Listening to the customer. That’s when you can start to change the culture – you now have some trust that you can spend.
12. April, 2013
A short summary of the presentation “UI Best Practices & Trends” held by Roland Studer of We Are Cube (slides).
- UIs are often bloated, confusing and frustrate users.
- A major factor is that features are often requested by people who won’t have to use the software later i.e. by (self) “important” managers. A variation of “Nothing is impossible if you don’t have to do it yourself.”
- “Don’t make me think” by Steve Krug (Amazon)
- “The interface is your product” (“Getting Real – The Book“). Customers don’t care about the code or the effort which went into the product, they only see what you show them on the screen.
- “Show me where I am”
- breadcrumbs, highlight tabs, use tree navigation
- “Use the F-Pattern“
- eyes travel left to right, top to bottom in Western cultures
- “Emphasize in Tables”
- gray out less important values, make important ones bold, group with color, use gauges instead of numbers
- “Affordance (sic): Show what’s interactive”
- Make it obvious for users to see where they can click
- “Make frequent uses accessible”
- Show only the most important actions as buttons (max. 5).
- Put the other, less signification actions in a popup menu.
- “Caution with icons”
- “A picture says more than 1000 words but which words exactly?”
- Icons can be confusing, hard to remember and they depend on culture/training.
- Offer at least user preferences to replace them with text or show text in addition to the icon or use tooltips.
- “Emphasize primary actions”
- Make the button stand out which the user most likely wants to click next or reduce visibility of less likely options (like “[Submit] [Cancel]“).
- Be careful that the visual cue doesn’t conflict with “this button is disabled”
- “Avoid OK / Cancel”
- Instead of asking “Is it OK to delete?”, ask “This object is still be used. [Delete Anyway] [Keep]“
- “Use undo if you can”
- Avoid confirmation dialogs. No one ever reads them.
- The user should never be able to do anything that isn’t reversible in some way.
- Allows users who got confused with an icon (see #6 above) to unto destructive action on touch screens.
- “Avoid left aligned form labels“
- The eye is only able to align elements when they are close enough.
- Right align labels, rely on browser search for locating elements if you have too many of them (which you shouldn’t)
- Or put the label on top of the fields (but this works better for forms where you have to fill in every single field)
- “Be nice to user input”
- Support “slang” like “next Tuesday” or “now” in date fields
- Keep illegal values so the user can edit them
- “Prevent errors”
- Calendar popups
- Offer a list of valid inputs in a drop-down list or use radio buttons
- “Instant Feedback”
- Show what has been entered correctly as well as what’s wrong.
- Display validation errors immediately (when the focus is lost) instead of waiting for the user to click on a “Submit” button
- Use tooltips on disabled buttons to explain how to enable them
- “Help users recover from errors”
- Avoid “There have been errors” dialogs; they aren’t useful in any way.
- Don’t tell what’s wrong, tell how to fix the error. If you don’t know how to fix it, will the user?
- “Responsive Web Design” – adjust the layout to available screen space. “Mobile first” helps to concentrate on the core features of your application. “Reduce to the max”, avoid distractions, show only the absolute minimum of data. Anything on the page begs to be noticed, so even if the user doesn’t read it, it will still take a tiny bit of concentration to ignore!
- There is a trend towards flat and minimal design. Example: http://basecamp.com/ where a lot of things on the page are interactive (i.e. responds to clicks) but almost everything looks like plain text.
- “Actions only on hover” – Show available actions only when the user hovers over some part of the page. Drawback: Doesn’t work on touchscreens since the user can’t “hover”
- “Implicit feedback” – Show a “saved successfully” message. Give hints in text fields.
Always keep in mind:
Developer != User
Product Owner != User
UI Guru != User
Do usability testing. If you can’t, try installing the product on a laptop and ask someone in the corridor to use it for five minutes. A little is better than nothing. You’re blind to your own prejudices.
26. February, 2013
David Blake posted a current overview of Man in the Middle type attacks: 15 Surprising Ways You Could Fall Victim to a Man in the Middle Attack
- Key-loggers (hard- and software)
- Browser plugins
- Cameras (a.k.a Shoulder Surfing)
- Wireless attacks
14. February, 2013
A unit test checks a certain feature of the software. When it fails, you usually know exactly where to look for a place to fix the problem. They are short, compact and fast.
They come at a cost, though: You have to replicate the setup code in your test.
This is an important point. To use a feature of your software, you always have some set up to do. This set up has to exist in your production code. For unit tests, you will have to copy some parts of this code into your tests because usually, the setup of the production code simply isn’t fine grained or flexible enough to be useful for tests. Think tests which check the error handling: Your production code usually can’t build mock objects that raise errors when certain methods are being invoked.
An integration test reuses the production configuration. It tests many features at once, in the same order and with the same or at least a very similar environment that your final application will use. They are high level and often much easier to set up. But that comes at a cost:
- They are slow
- When they fail, there will be many places which could cause the issue, so fixing them is more expensive
- They break more often because you have more dependencies
- Setting up a test for the “success” scenario will be simple but injecting mock objects to cause exact error states will be much harder
So be aware what kind of test you’re writing.
8. February, 2013
“Things users don’t care about” is something every software developer needs to know about.
Kudos go to Thomas E. Deutsch for finding and telling me about it.
16. May, 2012
If you’re interested in the conflicts between software and documentation, Alex Lagarde wrote a great post about that: Intent Discovery – Part 1 : the intents behind softwares.
It explains what the different (and conflicting) goals are between the “technical space” (source code), “model space” (design and architecture) and “document space” (what people need to use the software successfully). And he promises some solutions with the new Eclipse project “Intent” (and the second post in the series).
23. February, 2012
The EFF has started a new campaign to clean the patent system.
I’ve blogged about the many problems of the parent system when it comes to software. If you care as well, at least spread the word. If you want to do more, check out the EFF site or maybe help with the Patent Busting Project.
9. August, 2011
In his post “Martin Fowler on Software Patents“, Martin Fowler joins the growing group of people who argue against software patents in their current form.
13. July, 2011
Archanaa Panda wrote a good piece on logging and how to avoid some of the many pitfalls: High Performance And Smarter Logging
While the article is about log4j, most of it (except for the “if (log.isDebugEnabled)” part) still applies even if you’ve already moved to slf4j. I especially like that she enumerates all the various goals that you try to achieve with logging.
12. July, 2011
Jim Bird has written a great post about reasons to fix bugs and reasons to leave bugs alone: Zero Bug Tolerance Intolerance