The Best Way to Learn How to Use an App? Figure It Out Yourself.

5 min read
  • When you try an app for the first time, spend some time figuring out how it works on your own instead of googling right away.
  • Use skills and shortcuts you’ve learned when using other apps and try to apply them to the new app.
  • Good developers will always make sure that their app is as intuitive as possible, meaning: easily “figureoutable.”

This weekend, I’ve been trying a new app, Scapple. The app isn’t exactly new, but it was new to me. With every app you discover, there comes a learning curve. Some functionalities are apparent immediately; others are hidden behind obscure menus or keyboard shortcuts. One way to approach a new app is reading the manual or watching introductory videos. Or even worse: never getting past the elementary stage or abandoning the app altogether. But there’s another strategy: figuring things out on your own.

Scapple is an app made by Literature & Latte, who you might know from their smash hit Scrivener. The app has been around for a long time, but it doesn’t seem to be updated a lot anymore. It reminds me of a mind mapping tool, albeit with a less restrictive approach. While on mind maps, everything is quite tied together (even though you can create multiple main nodes), with Scapple, you can put items anywhere and then connect them with lines. Similar to a whiteboard, just with endless space.

Some things are always the same

The good thing about an app like Scapple is that it’s simple. It does one thing, but it does it reliably, fast, and overall well. When you start the app, it teaches you two things to get started:

  1. Double-click anywhere to create a note.
  2. Drag notes onto one another to make connections.

The rest you have to figure out on your own. Some things just work like in other apps: There’s a control at the bottom for zooming in and out of the document, and when you right-click on a note, a context-menu pops up providing you with further options.

But when you drag a note onto another one, as the app suggests, you realize that it always creates a simple line connection between them (dashed by default). And you may wonder, how can I make it into a straight line with an arrow? Or with arrows on both sides?

Making sense of it all

Sure, you could consult the manual, watch a video, or google. But there’s some value in figuring these things out on your own. Not only will the newly learned behavior stick more easily, you’ll also learn something about how good software is made.1 These are skills you can use with many other apps, too. If you learn to think like a developer, you might never or only rarely need to read a manual ever again.

When you drag a note onto another one in Scapple, for example, try holding down various function keys. What happens when you press OPTION ⌥? Instead of drawing a dotted line, the items will be connected with a straight line and an arrow (directed at the dragged-upon item). What happens when you press OPTION ⌥ + CMD ⌘? The arrow will point in the opposite direction. Can we also make it so there’s an arrow in both directions? Sure, let’s try another combination: CMD ⌘ + SHIFT ⇧. Works flawlessly!

While this process shows the trial, it skipped the entire error part. Inevitably, you’ll try things that don’t work or that have adverse effects. That’s not a big deal, since you can revoke almost anything by pressing CMD ⌘ + Z. (It’s a good idea, though, to try these things in a new document that you use only for testing.)

For me, this is how I always approach software. Through trial and error, you learn more about an app than when you’re just told what to do. You learn to think like a developer by asking yourself, “How would I have designed this?”, and that makes you a better and more mindful user in the long run.

  1. There’s good and there’s bad software. Some developers are extremely considerate when it comes to user experience. They take into account how similar goals are achieved in other apps and build upon this already learned behavior. Other developers entirely disregard that and try to find “new” and “innovative” ways to “express themselves.” Often, that just leads to frustration. Good user interfaces use as much of what is already known to the user (and what has worked for them in the past) as possible. But every developer is, of course, free to adhere to that rule or not. You’ll eventually encounter bad applications that you can’t seem to figure out without a manual. But maybe that’s also a sign that you should keep looking for a better alternative. Jump back.︎