• Home
  • Events
  • About
  • IntelliJ IDEA series (IV) interaction design

    January 7th, 2011

    Caution: this post contains philosophical content!
    (at least some readers call it so when I reflect on what makes software great)

    Please note that this is for Groovy and Grails development on Mac OS X with Swiss-german keyboard layout, so the keybindings may differ on your machine. (For Windows, you most often can replace Cmd with Ctrl)

    Let’s start with a simple example.

    Cmd Shift A

    pops up a simple text field (and one checkbox) where you can select from all available actions in case you have forgotten the shortcut or its place in the menu tree. It appears like the picture below if you e.g. look for the dependency analysis features by entering “Dep

    • First of all, this feature is immensely useful for itself. Especially, it is much quicker than scanning through the menus or reading through the help pages. Apple, Microsoft, could you please steal the idea for your software products?
    • Second, note how slick the search “dialog” is. You hardly recognize it as a dialog at all. Many other software products pester their users with ridiculously overloaden search dialogs. JetBrains learned from Google’s success: one entry field is enough.
      Providing many options to the user is actually the easy way. Taking the hard decisions of what not to show is the true mastery of interaction design.
    • Finally, the way that you narrow down the options is consistent throughout the whole application. Here is another example: use

    Cmd , (comma)

    to open the setting dialog. Now let’s assume that you want to enable the (very useful) feature to highlight all usages of the symbol that contains the text cursor (also known as “caret”). There are so many possible settings. How do I find the respective checkbox? Just start typing in the search field and the settings view narrows down the options and highlights the candidates.
    Try entering “highl” and you will see in the Editor section the checkbox “Highlight usages of element at caret“.

    The consistent availability of interaction concepts is key to a usability.

    Here are some more of those consistent features. When used in differenct contexts, they may technically do totally different things but still serving a very similar user goal.

    F2 (Shift F2 for backwards)

    jumps to the next error but also to the next inspection warning, i.e. the next point that requires your attention.

    F3 (Shift F3 for backwards)

    jumps to the next Find target (when you called the in-file finder with Cmd F) but also to the next usage of a symbol (when you used the “find all usages of symbol under caret” feature with Cmd Shift F7).

    F4

    from many different tools opens the selection in the editor and gives it the focus

    F5

    copy of classes or files, even Shift F5 for the “clone” refactoring.

    F6

    move pretty much any OO construct anywhere. Shift F6 for the “rename” refactoring.

    The point is that these actions are technically quite different in the different contexts but serve a similar purpose and so using the same shortcut is a consistent choice – easy to explain, easy to remember.

    So much for today. It was a bit more contemplative than usual. However, I hope I could inspire you to recognize more of the interaction design of the applications that you use – and maybe even to pay more attention to the interaction design of the applications you build.

    The next post will again be about hands-on tips.
    Dierk Koenig
    @mittie


    Canoo RIA Suite Beta

    April 1st, 2010

    Canoo Engineering is proud to present the next generation of UltraLightClient! Download the Beta here!

    The RIA-Framework (Rich Internet Application) has been completely overhauled and enhanced with a series of innovative and useful functions. These will enable more efficient and convenient deployment in future, as well as adding some attractive features to the design of the user interface.

    UltraLightClient will bear the name ULC Core from now on, and forms the basis of the new Canoo RIA Suite, which will officially be released at the beginning of May. The suite is designed in a modular fashion, allowing you to compose functionality according to your own needs. And you only pay for those modules which you actually require.

    .

    RIA suite

    The Highlights

    • The new Chart Functionality enables you to present even complex facts and figures clearly and simply.
    • Using the integrated Animations Framework you can develop dynamic and attractive content in future.
    • Further sophisticated graphic features allow even more attractive designs: transparency, rounded angles etc.
    • Easy integration to Google App Engine.

    THE NEW MODULES AT A GLANCE

    ULC Table Plus: this package enables you to implement even the most complex tabular requirements in a rapid and straightforward manner.

    ULC Web Integration: simply integrate any browsers such as Safari, Firefox or Internet Explorer into your application developed under ULC. Web services and plug-ins like Google Maps or Flash Player can thus be launched directly in the application.

    ULC Office Integration: this ULC Core module supports the future import and export of Excel and Word files out-of-the-box. The contents can then be stored as PDF files and later printed.

    ULC Enterprise Portal Integration: using this optional extra, existing portlet applications can be easily and efficiently augmented with ULC applications.

    ULC Visual Editor: with the optimized visual editor you can generate your ULC applications by drag & drop even more easily and, as usual, without any manual programming effort whatsoever.

    ULC Load: put your ULC applications though extensive load and performance tests using ULC Load. Thus you can be confident that your applications can bear up to the most rigorous demands in an operational environment.

    Download the Beta here!


    10 Lessons Learned from Usability Testing

    March 19th, 2010

    This morning I sat through a great presentation from one of my fellow Canooeys about Usability Testing. The presentation and discussion were in German, so I have no idea what anybody said; but someone had brought Black Forest Cake to share. Any meeting with Black Forest Cake is a good meeting, without exception.

    I was introduced to Usability Testing way back in 2003 in the UST Graduate Program in Software. The class was taught by a great professor named Robin Kincaid whose distinguishing credential was that he was literally at Xerox Parc when Steve Jobs came to see the first GUI. Now, Prof. Kincaid wasn’t working on that machine in particular, he just happened to be standing in the hallway at the time, but that is a good enough credential for a Minnesota university. I was impressed enough to spend the next seven years carrying the mission of usability testing forward with varying degrees of success. Here is what I learned along the journey.

    You Can Afford It

    The low cost of discount or guerilla usability tests is the UX community’s worst kept secret. Where did everyone get the idea that you need a video camera and a dedicated usability lab? You need about 15 minutes of a real user’s time and maybe one hour per user of preparation: 4 hours total (for those not so quick at math: just recommended a sample of 4 users). The problem is trying to sell a manager “discount” usability and then trying to explain that discount doesn’t mean inferior. We’d be better off calling it Agile Usability so people identify usability with removing waste instead of vice versa.

    You Have the Tools

    PowerPoint or other presentation software makes a pretty good prototyping tool because you can quickly create mockups and even link a few slides together with hyperlinks. The user can then sit in front of an actual computer when exploring usability rather than having to deal with printed paper. But pen and paper do work well, and there’s even an entire book on Paper Prototyping. Balsamiq and other tools look great and produce impressive looking results, but require an initial investment to get started. If you need to impress a client then look at using Balsamiq. If you just want to make a better product then there is surely a zero cost way to start usability testing at your company by using the office supplies and software you already have.

    You Don’t Need Training

    You know what’s often better than being taught how to do something? Learning to do it yourself through practice. My last project included an initially reluctant designer. To kick start our usability practice, I ambushed him with his own mockups, and used him as the user in a testing session. Then we turned around and did the exact same thing with real users. Just showing someone how it is done within 30 minutes was better than several weeks of failed persuasion in meetings and retrospectives, and he turned into a great advocate for this style of testing. Over the course of the project we practiced and continually refined our own usability process ourselves, without training or consultants.

    You Don’t Need an Expert Opinion

    Usability testing means putting together a low cost prototype, showing it to real users, collecting the feedback, and then revising your prototype. An expert opinion is valuable when you have no access to your target market. For example, if you need accessibility features in your software, and you can’t find suitably impaired users to test with, then relying on an expert’s opinion is a good choice. But before calling in the consultants, ask yourself how these consultants became experts in the first place. The answer is no secret: they practiced usability testing and read some books. Instead of calling in the experts I recommend just becoming one yourself: practice, read, repeat.

    A Usability Session

    Usability Won’t Bloat Your Process

    So you’re already doing use cases, user stories, design documents, and copious amounts of meetings… can you really afford to add usability testing into your process? There is a legitimate fear that delaying development in order to produce paper mockups, testing scenarios, and user feedback will postpone final delivery even more. But take a hard look at your current process: aren’t the inputs to usability testing (mockups and a user scenario) already being produced? So called Software Design documents are oftentimes crammed full with screenshots and mockups, user stories and use cases are just testing scenarios with a different name, and many shops will spend hours on the design by committee merry-go-round debating how an interface should look. Usability doesn’t change the artifacts you produce, it just asks you to produce them at a time when they are useful instead of useless.

    You Do Have the Time

    Designing a user interface during a meeting is one of the most costly ways to create a UI. Eight people for one hour is a full eight hours of company time, and usually with a poor result. Instead, why not perform four hours of usability testing and then spend 15 minutes reviewing the results in a meeting with those same people. It takes the same amount of time in the end, so there is no additional cost to adopting this technique once. You only don’t have time if you insist on continuing to waste time in other ways.

    It Works Best in an Agile Cycle

    Here’s a process that has worked great for me in the past: with 2 week iterations the designer worked ahead one iteration, working with the users and testing his mockups. At the end of the iteration, we developers presented our working and finished software to the users, and the designer presented the system that was going to be produced in the next iteration. A dude writing some stuff on THE LENS! Whoa.Then development took the mockups into iteration planning where we used the artifacts as a key guide to producing estimates and work breakdowns, while QA used the mockups as input and guidance for test creation. We didn’t start with this process, but after a few iterations of tweaking we were all quite happy with what we ended up with. If you’re new to usability then use the by-the-book approach at first, but revise the process to fit your team and your company.

    It Is Not Testing

    The hallmark of a good test is that it passes or fails. It satisfies a requirement or it doesn’t. Usability tests, on the other hand, make things better. Skeptics of usability studies often use this lack of precise results to dismiss the whole endeavor, saying that results of testing cannot prove which is the best user interface. This is true. Design reviews also cannot prove the best software design. Both software and user interface design can help you decide the better option out of several alternatives, but both are limited by what alternatives are presented in the first place. If you are asked to choose between two crappy designs then your final design will be… guess what? Crappy. Don’t let the best be the enemy of the good. Many practices exist to provide an improvement, not perfection. This is one of them.

    You Don’t Need Usable Software (maybe)

    Everyone wants usable software, but not everyone needs it. Sometimes a complex, hard to learn interface is better than a simple, easy to use one. Always ask yourself how the software provides value. Frequently, the answer is that it doesn’t. If software is just a tool to getting transactions completed, then the more transactions completed the better off your company is. I’ve worked in several call centers and seen two drastically different approaches to usability. In a call center, all of the operators receive training, and time spent operating software is an expense. In this context a user interface should be optimized to be as fast as possible to complete transactions, even if it requires training to use. Several methods exist to measure the speed of a UI, including GOMS and Master Clerical Data (MCD). If your customer will financially benefit from a fast to operate but difficult to learn system, then stop worrying about what’s intuitive and start worrying about keystrokes and mouse movement. Some simple arithmetic can create an eye-opening return on investment proposal. For more on this idea I recommend reading Humane Interface by Jef Raskin.

    It is Surprisingly Hard to Sell

    If you aren’t doing usability testing, then someone, somewhere has the job of making user interface decisions. These decision makers have power, and few people will give up power for nothing in return. Maybe it is a developer who produces screenshots as part of a design process, or maybe it is a manager who debates and decides how a form should look. If you want to try usability testing then you need to convince these people that it is worthwhile. A developer is typically easy to convince, because you can replace an ad hoc UI design process with something more rigorous, appealing to their engineering principles and padding their CV. A manager or analyst is much harder to persuade because they often are not rewarded based on the quality of the finished product but instead based on the amount of their input that ends up in the finished product. Selling usability can oftentimes be interpreted as making part of their responsibilities obsolete. This is true, good, and a difficult pill to swallow. I recommend involving analysts as a key member of the usability team, so that the energy they had put into committee decisions can be refocused to a better process. As for selling managers on the idea… I don’t have any successful tactics and would love to hear feedback or experiences you might have.

    Today, after several years of practice, I am just as excited and hopeful for usability testing as I was when I started. Many, many software shops could benefit from low ceremony usability testing. The key to getting value from it is to keep investment and costs to a minimum. Train yourself, don’t commit to fancy tools, resist the allure of pricey consultants, and just get on with practicing. Happy Testing!


    The renaissance of user-oriented interface designs

    January 21st, 2010

    Excerpt of  “Rich Internet Applications for Business”, an article by Hans Dirk Walter, CEO Canoo Engineering AG (in print).

    Alongside the ascendancy of the World Wide Web (WWW) as global information platform, its technology has increasingly been employed as the basis for enterprise applications in the course of the last 10 years. Web based application have successively squeezed out the previously widespread client-server applications. Ever more IT managers have recognised the operational advantages of centralised application management (re-)enabled through this technology and have placed a total emphasis upon HTML in their application development. This trend has rather conveyed the impression in recent years, therefore, that page based user interfaces were the last word, while user-oriented layout and design appeared consigned to oblivion.

    In the wake of the euphoria surrounding HTML there were always organisations who expressed their dissatisfaction at the shortcomings of pure HTML interfaces. Meanwhile, a significant number of middle sized IT companies made their money developing RIAs for such organisations. Publicly, however, these efforts scarcely attracted attention. It was not until the Eclipse project, with its popular Rich Client Platform (RCP)[1] several years ago, that the ordinary developer was once again reminded of the far more ergonomic interfaces of the client-server technology of the 1980s and 1990s.

    The term “rich client” now became newly synonymous with this technology.  Since RCP is a “fat client” technology it did not correspond to the centralised “zero footprint”[2] approach of classical HTML applications. These benefits, in which no application specific code whatsoever was of installed on the client, thus employed so called “rich thin client” technology, which in turn however merely represented a transient niche. It was not until Jesse James Garrett coined the phrase “Ajax”[3] in 2005, thus bestowing respectability on JavaScript based Internet technology that the idea of “Rich Internet Applications” became familiar to a broader public, who has since been demanding the same level of interface interactivity in online connections as that of pure desktop applications.

    This trend has been reinforced to now by discussions about the fuzzy, yet enigmatic term “Web 2.0”[4]. According to this “hype”, the hitherto largely passive bulk of internet users would become highly active web content authors in the coming years or even site “programmers”. Thus, “Web 1.0 was commerce. Web 2.0 is people. […] 2015, everyone alive will [..] write a song, author a book, make a video, craft a weblog, and code a program” (Kelly, Wired[5]). However, in order to motivate and enable the average surfer not just to consume but also to actively contribute new content, the web needs to be equipped with a suitable interactive interface, with whose help the user can rapidly and easily become active. RIAs bridge this gap perfectly with respect to the dizzying expectations of Web 2.0. They represent the technology, without which the entire aspiration and utopia would evaporate.

    However, RIA technology offers so many advantages not only for the Web 2.0 community but also for everyday enterprise applications, that the demise of exclusively HTML based “poor ugly web applications” (PUWA) is foreseeable in the not too distant future.


    [1] Jeff McAffer, Jean-Michel Lemieux: Eclipse Rich Client Platform; Addison-Wesley, 2005.

    [2] “Zero footprint” means that no additional Software needs to be installed on the client in order to launch an application

    [3] Jesse James Garrett: AJAX: A New Approach to Web Applications; www.adaptivepath.com/publications/essays/archives/000385.php

    [4] Tim O’Reilly: What is Web 2.0;

    [5] Kelly, K.: We are the Web. In: Wired 13.08 (08/2005)


    Gartner Oracle: Smartphones to dominante PCs by 2013

    January 18th, 2010

    .

    The well known research firm Gartner just published it’s Top Predictions for IT Organizations ans Users for 2010 and beyond, covering developments which definitely affect the RIA market, too. Their key findings are:

    • IT Ownership: “By 2012, 20% of businesses will own no IT assets”.
    • Cloud Computing: “By 2012, India-centric IT services companies will represent 20% of the leading cloud aggregators”.
    • Social Networking: “By 2012, Facebook will become the hub for social network integration and Web socialization”.
    • Sustainability: “By 2014, most IT business cases will include carbon remediation costs”.
    • Internet Marketing “will be regulated by 2015, controlling more than $250 billion in Internet marketing spending worldwide”.
    • Mobile Commerce: “By 2014, over 3 billion of the world’s adult population will be able to transact electronically”.
    • Context Aware Computing “will be as influential to mobile consumer services [..] as search engines are to the Web”.
    • User Devices: “By 2013, mobile phones will overtake PCs as the most common Web access device worldwide”.

    Perhaps the most aggressive outlook is the prediction that mobile phones will overtake PCs as the most common Web access devices worldwide by 2013 — Morgan Stanley wasn’t quite that courageous. If we look closely, Gartner predicts that mobile phones will drive the higher number of website accesses “due to the sheer weight of device numbers”, but the “the bulk of page views will continue to occur through larger-format devices”. However: The RIA sector has to get ready for the mobile revolution, existing websites and web-based applications should be designed to be device-independent and their information structure has to be redesigned for mobile phone access.

    Canoonet Mobile

    CanooNet Mobile V2 (announced for 2/2010) demonstrates a successful redesign of a content structure for mobile access: No information should be positioned more than 3 clicks away from the user.


    css.php