5 questions to prepare for quality assurance

When we begin quality assurance (QA) at Brighten, we always ask 5 questions about the project. Our answers to these questions establish the framework for the rest of our QA process.

The questions

1. Does my product have any known issues?

Try to think of anything that you already know isn’t working. At Brighten we always look for two categories of items:

• Anything we still need to do that may be forgotten or be for “last minute” but strongly affect testing.
• Anything that the customer still needs to do or decisions we are waiting on that will affect testing.

2. Who should be able to use my product?

This usually relates to the technology the user has access to. In the case of websites, they can look very different in older versions of web browsers, and some functions may not work without significant alteration. Depending on the technology your audience has access to, supporting older browsers may not be worthwhile. Some questions you may want to answer here are:

• What web browsers and versions will we support (Internet Explorer 7, Chrome 5, etc)?
• What languages will we cater to (English, Spanish, French)?
• What additional software can we expect our users to have (Flash, Java, Reader)?

3. What should my product be able to do?

This is certainly one of the most basic questions about your product, but answering this question well and with enough detail will make make all the difference as you begin QA testing. In this step you want to identify everything your product should accomplish. And I mean everything – try to put your detail oriented glasses on and think of every little thing this product should accomplish, including the seemingly obvious ones.

Depending on how comfortable you are with technology, you may be able to highlight some potential trouble spots in this list. For example, when we create these lists, we preface items that are most likely to have trouble in different web browsers with a “[CB]” for “cross browser”.

Here’s a small portion of one of our recent functionality lists, looking specifically at the “job description” portion of the product.

• Job Descriptions
  • Delete
    • Deletes job descriptions that don’t have dependent job positions
    • Does not delete job descriptions with dependent job positions
  • Both edit links (pencil and title) work correctly
  • Create link “Start a Job Description” works
  • Edit/Create
    • Text field data is correctly updated
    • [CB] Activities/contexts/skills/tools all add and remove correctly
    • PDF downloads and displays properly
    • Last updated displays correct date
  • Last updated displays correct date on main job descriptions listing

4. What should the product look like?

If you have copies of the designs for your product, this would be a good time to pull them out. Give them to whoever will be doing your testing so that they can evaluate how well the product matches the design in different environments (this could be a different web browser or even a different operating system).

5. Is there anything we’ll need to change before we launch this product?

Thoroughly identifying these items can help you avoid embarrassing post launch issues. Here are a few questions we usually ask when completing this part of the checklist.

• Do we need to change the e-mail addresses that any forms send to?
• Is there test/sample content that needs to be removed?
• Are there crucial items that should be rechecked just before and just after launch?

Testing the product

In the weeks to come, I’ll be covering who should test the product, and some of the basic strategies our QA specialists employ when evaluating products.

Do you go through a similar process when preparing for QA? If not, what does your process look like? Let us know in the comments below.

References

• Shower comic from CRMNext

Our strategy for worry-free backups

If you’ve put off setting up a solid data backup system for yourself or your team, spend 5 minutes reading this post on how we chose and maintain our simple, (nearly) hassle-free approach. It could save you weeks (or years) of regret. (Note: This post will be particularly helpful if you’re a Mac user.)

What do you want your backup solution to protect you from?

There are lots of tools available for data backup, including services like Carbonite and JungleDisk, software like SuperDuper! and Time Machine, and handcrafted scripts using rsync. The first step to choosing the right solution is deciding what matters to you.

The big question is what do you want your backup solution to protect you from?

1. Are you just concerned about losing your files, or also about losing time while you recover files?
2. Do you need protection against fire and theft, or just hard drive failure?
3. Are you willing to re-do this week’s work if your primary hard drive fails, or only this hour’s work?

The solution we needed

For us, every hour of lost work is costly, whether it’s because data we need is unavailable temporarily, lost forever, or just because a computer isn’t working right now. Any of these problems could result in project delays that could hurt our clients and our business.

We decided we needed:

1. Off-site backups not more than 1 week old (protection against fire and theft)
2. Back to work in less than 2 hours in case of hard drive failure
3. Back ups every hour
4. A very simple plan (so we’d actually follow it)

Our chosen tools

Time Machine

Time Machine comes with Mac OS X, so it didn’t cost anything extra, and it performs automatic backups in the background every hour. Each team member has a backup drive for Time Machine that remains at their desk at work.

It can take many hours to restore a complete hard drive from Time Machine though, so we needed another tool to provide quick restores and also to address our need for off-site backups.

SuperDuper!

SuperDuper! creates a bootable mirror image of a primary hard drive on a backup hard drive. This means that if the primary hard drive fails, we can begin working again on the backup drive immediately, with no restore time.

Since we back up to hard drives that are compatible with our computers (Western Digital drives
with Acomdata enclosures), if a team member’s hard drive fails he can remove the failed drive, immediately put the backup drive in its place, then order a new backup drive.

If a team member’s whole computer goes down, he can connect his backup drive to any recent-model Mac and boot up from the backup drive as if it were his own computer.

Pairs of team members share a pair of backup drives for SuperDuper!. Each drive has two partitions, one for each person in the pair. Pairs swap drives once or twice a week. These drives are kept at home so we have an off-site backup that is less than 1 week old for each team member (and our development server) at all times.

Making sure we follow through

“A plan in the heart of a man is like deep water, but a man of understanding draws it out” (Solomon, Proverbs 20:5).

We started by adding a SuperDuper! drive swap as part of our agenda for our weekly team meeting, but I often forget about it. We’ve also talked about putting up a sticker chart to keep track of our swaps, but never got around to it.

So while writing this post I took out a scrap sheet of paper and listed each pair of team members with a place to write the date each time they swap drives and posted it on our whiteboard. Sometimes polish just isn’t necessary. Now we can all see who’s swapping. And once we get to a collective 25 swaps, we’ll reward ourselves with a stop at the local Gelateria.

—

As our team grows this decentralized approach may eventually be replaced, but for now it’s proving quite flexible and scales nicely. I’ve even set it up for my mom on her new Macbook Pro, with some slight modifications (she doesn’t have a team member to pair with, so she keeps one drive at work and one at home, permanently).

What tools and approach do you use to manage your backups?

How we manage large projects

One of our recently completed projects was a relatively complex web application. Here are some interesting facts:

• 3 primary developers, 2 others involved
• 8 months
• 90 MB of data
• 41,000+ lines of code in 510+ separate files

With projects like this one, there’s always a risk that the size of the project itself will actually hinder our progress and ability to meet the client’s needs quickly and efficiently. As a project gets larger and lasts longer, the effort required to keep things organized and moving forward increases dramatically. In fact, the chances that the project will be finished at all actually goes down substantially. For projects over 6 months in duration, the average success rate (completed on time, under budget) has been shown to be below 50%. [ Agile and Iterative Development by Craig Larman, p. 71 ]

That’s not a statistic we want our clients to have to deal with.

1. Prioritize features and functions

One of the most common reasons for failed development projects is having too broad a scope. After all, the duration of a project is directly related to the scope of its features. A recent study of large projects and their implemented features showed that over 45% of the features initially requested are never used in practice, with another 35% seldom used. Shockingly, only 20% of features in initial project scopes are actually used regularly. [ Agile and Iterative Development by Craig Larman, p. 73 ] In other words, for many projects, a large portion of the time, energy and money invested in them is essentially wasted.

We combat this danger by spending time early on helping our clients analyze their needs and choose only the most important features and functions. If the project is coming in on time and under budget, there’s always room to add those extra touches from the wish list later on. But the reality is, if we don’t intelligently pick and choose, the project is on rough ground right from the start.

2. Short development cycles

Developing a large website or web application is a lot like constructing a building. You need plans before you begin if you want to obtain a satisfactory result. And if those plans are going to change significantly, you want it to happen as early on as possible. Changing the floor plan after sheetrock is on the walls would be costly and time-consuming. In the world of software development, this risk is exacerbated. The longer a project takes, the more likely things are to change along the way. And when they do, it can cause major delays.

There are a few things we can do to lower the chances of budget-breaking changes late in the development cycle. First and foremost among these is “iterative development”. In simple terms, we break the project into smaller, more manageable pieces. Instead of tackling the entire feature set from day one, we take things in bite-size chunks of 2-3 weeks in length. During each of these development cycles, we examine the most important features we’d like to implement, work with the client to make sure we’re meeting their needs, and finish by testing and reviewing the outcome of that particular piece. This lowers the risk of failure by reducing the feature scope, shortening the duration, and giving us a chance to quickly adjust to any changes as we go along.

3. Source code management

Dealing with project source code is a regular task for developers, but one that can lead to serious problems if not handled correctly. If you’ve ever collaborated with others on a single document, you’ll know that information can be lost if more than one user is editing simultaneously. The easy way around this is to restrict editing to one user at a time. For a large project however, this limitation is unacceptable. For the project I mentioned at the beginning, we often had 3 developers working with dozens of files at any given time, and regularly needing to work on the same files simultaneously. Coordinating with each other to make sure we had the latest versions and weren’t overwriting each other’s changes would have slowed progress to a crawl.

The solution? Source control management (SCM). SCM software stores source code in a simple database called a “repository” and tracks each of the changes made to the code as development progresses. Because the SCM is keeping track, it can intelligently merge changes from multiple developers within a single source code file. If something goes wrong, it can even help undo any changes made by mistake. There are several SCM tools available, but our favorite is Git. Git is a “distributed” SCM, meaning each developer has his own code repository that he makes changes to. When we’re ready, a simple command merges all our code into the master Git repository for the project. A wonderful benefit to using an SCM is that making quick changes to a project is trivial. Any one of the developers has full access to the latest copy of the project code, and any changes he makes are instantly available to all the others. An SCM is essential for any project involving more than one developer.

4. Centralized project testing

Another area that can often slow down project teams is the test environment setup. Each developer working on a project needs to be able to quickly test the code he’s writing, often in multiple browsers to ensure compatibility. The usual way to do this is to set up a local web server on every developer’s system. Aside from the time this consumes every time a developer is added to the project, it can cause further delays any time a dependency or server extension is required in the project code. This then has to be properly installed or upgraded on each developer’s machine independently. Having multiple server environments also increases the general amount of effort required to keep things running smoothly.

At Brighten Labs, we got tired of dealing with these headaches, and decided to set up a single, central server environment for testing. All the code being edited by our developers resides on this central system. By giving the server a public IP address and each project its own subdomain, a developer can even connect securely and continue working when outside the office. Any changes can be tested instantly on this subdomain address, without even being committed to our Git repository. This takes half a dozen steps out of the usual process, speeding up development and testing substantially.

—

With over 50% of larger projects (over 6 months duration) going beyond deadlines and over budget, we want to do whatever we can to make sure our clients don’t have to feel that pain. I’ve mentioned four of the major ways we’ve found to combat “large project syndrome”, but there are many other things that can help.

Do you have a story involving trouble during a large development project? Maybe you have some strategies you’ve discovered along the way? Feel free to sound off in the comments.

Don't buy umbrellas, test your product

In 1999, the U.K. Passport Agency implemented a new Siemens computer system, which failed to issue passwords on time for a half million British citizens. The Agency ended up spending £12.6m to try and fix the mess, including £16,000 for umbrellas for the long lines of people outside the building waiting for a passport.

Quality assurance (QA) is easy to forget or underestimate when a project is low priority or quickly approaching a deadline, but missing this step will almost inevitably cost more in the long run. Had the Agency spent more time testing the new system, and not pushed it live so quickly, millions could have been saved. Though you may never have to buy umbrellas to solve problems caused by inadequate testing, you’ll likely incur serious costs if QA is underestimated.

At Brighten we’ve found that, depending on the project type, it is wise to devote up to a quarter of total project time on QA. Although this may seem like a sizable chunk of time, it keeps us from spending that time in the future, and allows us to deliver quality initially.

Over the next few weeks I’ll be writing about some of the key parts of QA for the web. I’ll share some of the techniques that we’ve found to be useful in our QA process, and some ways we’ve made our QA process more efficient. At this point I’m planning to cover these topics:

• Our recommended QA process
• Choosing who should do the testing
• How to test:
  • Functionality
  • Layout and design
  • User experience.

Do you have any other questions about the QA process that you’d like answered? What kind of experiences have you had with QA (or the lack of it)? Let us know in the comments below.

References

• Photo of umbrella from // solidether on Flickr
• BBC News: Holidaymakers may foot bill for passport chaos

If I borrow for inspiration, am I a bad artist?

Creativity—its a mysterious thing. As a graphic designer and amateur photographer, I’ve spent a significant part of my life struggling with how sporadic creative inspiration can be. I’ve had to admit that I can’t control it at will. Maybe this is old news, but for me, it was a surprising realization. Most of us in the creative arts have at some point stared at a blank sheet or screen wondering why nothing was spilling out of our imaginations. Aren’t we supposed to be the professionals? Why is it such an incredible feat to come up with something original? Now, either I’ve expertly deluded myself into thinking I have any creative talent at all (possible), or I’m misunderstanding a key aspect of the creative process.

In my estimation, the number of truly, ultimately creative individuals in all of history can probably be counted on both hands. Their talent was so great that we would expect one of these geniuses to be able to birth a masterpiece while locked in a white-walled room sans outside influence. This ability to seemingly bring “something from nothing” is proof of at least one thing differentiating the masters from those of us lower on the creative continuum—appreciation and reverence for inspiration.

When I’m faced with a blank slate (a new website, brochure or book cover), my creative process often goes something like this:

1. Stare at the screen for 20-30 minutes, hoping the design will magically appear
2. Give up
3. Visit a few websites showing the latest trends and examples
4. Meld the best elements from the examples to create a “new” piece that fits the client’s requirements

I can tell you from experience, this process is definitely not unique in the creative arts industry. Is it stealing? Some might think so. Yet even the most talented artists will readily admit being influenced by others in their realm of work. So where do we draw the line? When does looking for inspiration become shameless copying?

Some quick research into the classical works shows us that even the most revered composers were guilty of borrowing for inspiration. A passage in Handel’s Messiah, for example, was strongly influenced by Fuga a Quattro Voci, a piece written years prior by Arcangelo Corelli. Many of Bach’s chorals were harmonizations of existing Lutheran hymns. Interestingly, we give Bach most of the credit for these hymns, not because we think he was the original composer, but because of how exquisitely he pieced together the alto, tenor, and bass parts. We stand in awe of masters like Handel and Bach not because they never borrowed from existing pieces or from their contemporaries, but because of the perfection with which they fit together each element in their compositions.

And this is precisely my point. Great artists don’t necessarily borrow less often. Their skill lies in the beautiful perfection they’re able to create with the elements they have, whether original or taken from others. What results is something that often appears new and different—something great—even if it isn’t purely unique. The reality is (as Solomon wrote in Ecclesiastes 1:9), “...It has all been done before. Nothing under the sun is truly new.” With this realization, my focus has begun to change. When I’m working on a design project, instead of worrying that what I’m creating may be similar to what someone else has already done, I try to focus on taking the best elements and combining them in the most beautiful and effective way.

So don’t be afraid of looking for a little inspiration outside of your blank canvas or screen. Its ok! You’re not committing a crime by appreciating and borrowing a little from another’s work (as long as you’re not violating copyrights or trademarks, of course). Just make sure you take the next step and add your own touch. To be a great artist requires more than just combining pieces from everyone else’s ideas. Like a master composer, you have to figure out how to combine the elements together into something greater than the sum of the parts. Something that seems new and different. Something inspired.

Cure flat forehead phenomenon in 10 minutes

If you get stuck on a problem in your HTML, JavaScript, CSS, or other code, stop banging your head on it and ask for help. With the wildly popular website Stack Overflow, it’s faster than ever to get the answer you need. Gone are the days when you have to slog through page upon page of mailing list archives to find, finally, that the problem remained unresolved.

The genius of Stack Overflow is that it rewards those who give great answers. Programmers race to answer a question faster and better, receiving “reputation points” when you accept their answer.

Many questions are answered within minutes of being posted, and some get their first response within a matter of seconds. In some cases, however, a question will go unanswered for a long time. Here’s how to get answered quickly:

1. Use the search box at the top of any page on the site to see if the question has already been asked.
2. Log in. OpenID is supported, so you can use your Gmail or Yahoo! account to log in.
3. Carefully write the title. Remember, people are racing to find questions that they think they can answer, so make it specific and concise.
4. Describe exactly what you have tried, and include code snippets. The person attempting your question should be able to use the code you provide to reproduce the problem on their own computer.
5. Format your code snippets. Indent the code four spaces, and it will appear in a gray box with syntax highlighting. Use the preview pane below the question box to check if your question is easy to read.
6. Describe the symptoms. Never, ever say “it’s broken” or “it doesn’t work.” Instead, describe precisely what you expect to happen and what is happening instead. Include all error messages and any other clues.
7. Help them help you. If an answer isn’t helpful, add a comment describing why. People are likely to revise their answer to make it more helpful if they think they can.
8. Ignore jerks. Resist the urge to comment on rude comments or answers. If an argument starts, people are more likely to join the argument, rather than answer your question.
9. Mark your favorite answer. The person who wrote it will then get a reward of 15 points, and you’ll get 2 points. Otherwise you’ll get a low “accept rate,” which reduces the chance that anyone will answer your future questions.

Measuring your marketing in 3 simple steps

A lot of time and money is spent to drive online traffic these days – Google AdWords, SEO, billboards, radio sponsorship, magazine ads, not to mention the social space. It’s great to have time and money to invest in marketing, but what kind of a return are you or your clients getting? This post will walk you through a quick way to determine which marketing methods are getting you results online.

For an example, let’s use CashCurve, a dead-simple web app for cash forecasting that we recently launched. At this point we’re just looking to find a few subscribers to try it out and give us some feedback. So we posted updates about CashCurve on our personal Facebook pages, blogged it, e-mailed folks, posted it on LinkedIn, and asked for feedback on Hacker News.

In just a few minutes in Google Analytics we can figure out what method of marketing was most effective. Here’s how.

1. Segment visits by traffic source

The natural place to start is by looking at our top traffic sources. Where is our traffic coming from? In Google Analytics, simply click on “Traffic Sources” and then “All Traffic Sources”.

Clearly Hacker News (news.ycombinator.com) has brought in the most visits for CashCurve. Number of visits tells us nothing about the quality of traffic though.

2. Segment visits by conversion

Now, in addition to segmenting by traffic source, you add segmenting by conversion. Most commonly this will be people completing an action on your website, like signing up for an account, submitting a contact form or completing a purchase.

This can be done with “Goals” in Google Analytics, but custom segments provide much greater flexibility. All you need to know is the URL someone would visit only if they completed the outcome. On CashCurve, this would be someone who visits the sign up form and then visits the Dashboard. Here’s how to set up your custom segment:

1. Above your traffic graph, beside “Advanced Segments” click on “All Visits”
2. Click “Create a new advanced segment”
3. Under “Dimensions” click “Content”
4. Drag “Page” to the “dimension or metric” area on the right
5. Now enter the exact URL for the outcome you’ve chosen (e.g. /dashboard)
6. If the URL for the outcome you’ve chosen has a part of it that is variable (e.g. /dashboard?123) then change “Matches Exactly” to the appropriate condition.
7. You can add additional refinements to this segment with “or” and “and” statements.
8. Enter a name for your segment below and click “Create and Apply to Report”

Beside “Advanced Segments” above the graph you should now see the name of your segment. Click the name to display Advanced Segments again, check “All Visits” and click “Apply”.

3. Dig for insights

We can begin to uncover our best marketing channels by answering the following questions using our report.

1. Which traffic source generated the highest number of conversions?
2. Which traffic source generated the highest conversion rate (%)?
3. Which traffic source generated the highest degree of engagement (low bounce rate, high pages/visit and average time on site)?

For CashCurve, we can see that the only marketing channel we pursued that generated results was Hacker News. The other top 3 traffic sources are likely related to Hacker News as well. One interesting twist is that Twitter’s conversion rate was over 5%. The sample is too small for clear conclusions, but it does mean providing easy ways to tweet headlines in the future could be very beneficial.

Which marketing channel has been most effective for you? And the bigger question, why?

FreshBooks, Ruby on Rails, and OAuth

In our experience working with OAuth, Ruby on Rails, and the Freshbooks API, we’ve found the documentation to be sadly lacking. In this post I’ll explain how we’ve managed to get these three to play nicely with each other. We’re running Ruby on Rails 3 with the ruby-freshbooks and oauth gems installed.

Getting Setup

1. We registered to be a FreshBooks OAuth application. It can take up to 5 days for them to approve your application, so you’ll want to do this step right away. To apply, login to FreshBooks, click on “My Account” then “FreshBooks API”. If you don’t already have a FreshBooks account, you’ll need to create one. Once registered, you will have the two key pieces of information needed to continue:
   • Consumer Key: Your FreshBooks system name (the portion of your account domain before freshbooks.com)
   • OAuth Secret: Found under “My Account” then “FreshBooks API”.
2. We added three fields to our users table in our database. You’ll need to be able to store each users FreshBooks URL, and if you don’t want them to have to log in to FreshBooks repeatedly, a place to store their access token and secret. (See the Token Expiry section in the Freshbooks OAuth Docs ).
3. We installed both gems (ruby-freshbooks 0.3.0 and oauth 0.3.6). UPDATE: We’ve found that different versions of these gems don’t work well with our code.
4. We installed our basic library code in the lib folder. We relied heavily here on the examples found in Paul Gallagher’s Twitter OAuth sample.

The Code

In a new Freshbooks controller we created three key actions:

Getting a Request Token
This action gets a request token from Freshbooks and stores it in the session for later. It then redirects the user to the FreshBooks authentication screen. They log in, and FreshBooks returns them (along with a verifier) to our callback method.

def request_token
  fb = FreshbooksOauth.new(current_user.fb_url)
  @request_token = fb.get_request_token(fb_callback_url)
  session[:fb_request_token] = @request_token.token 
  session[:fb_request_token_secret] = @request_token.secret
  redirect_to @request_token.authorize_url    
end

Callback
In the callback action, we get an access token and secret using the data we’ve gathered so far. We save those in the database so the user doesn’t have to repeatedly go through this process when they want to access Freshbooks data through our app. Then we redirect them to the show method where they can view the data.

def callback
  fb = FreshbooksOauth.new(current_user.fb_url)
  @access_token = fb.exchange_request_for_access_token(
          session[:fb_request_token], 
          session[:fb_request_token_secret], 
          params[:oauth_verifier])
  current_user.update_attributes(:fb_token=>@access_token.token.to_s, 
          :fb_secret=>@access_token.secret.to_s)
  redirect_to fb_show_path
end

Showing FreshBooks Data
The show action is what we send users to by default when they try to import FreshBooks data. If they have not been authenticated previously (i.e. we don’t have an access token or secret for them), or if there’s an authentication error we redirect them to the _request_token_ method to authenticate with FreshBooks. Otherwise we use the Ruby-FreshBooks gem to make a simple request to FreshBooks.

def show
  if((current_user.fb_token.blank? || current_user.fb_secret.blank?) 
      && session[:fb_error].blank?) 
    session[:fb_error] = true
    redirect_to fb_request_token_path 
    return
  end

  client = FreshBooks::Client.new(current_user.fb_url+'.freshbooks.com', 
          'YOUR FRESHBOOKS SUBDOMAIN HERE (i.e. clockwork)',
          'OAUTH SECRET HERE', 
          current_user.fb_token, 
          current_user.fb_secret)
  @invoices = client.invoice.list :status => 'unpaid'

  #If returns error
  if(@invoices['error'])
    #If first error, get new request token and try again
    if session[:fb_error].blank?
       session[:fb_error] = true
       redirect_to fb_request_token_path
    else
      session[:fb_error] = nil
      redirect_to freshbooks_path, 
              :notice => 'There was an authentication error'
    end
  end
end

We hope that this is helpful to you. Does the code work for you? Any suggestions for improvement? Let us know in the comments section below.

Downloads

FreshBooks Controller
FreshBooks OAuth Library

References

Ruby FreshBooks Gem
OAuth Gem
Rails Twitter OAuth Sample

Easily test websites on the iPhone / iPad Simulator

Read this article if:

• Your client wants the website to work on the iPhone or iPad but you don’t own one yet.
• You’ve been testing on an iPhone but would like to speed things up by using a keyboard and mouse.

iPhone Simulator can simulate both the iPhone and the iPad, and comes with Mobile Safari. In this article, I’ll show you how to install it.

Before you start, make sure that you are running Mac OS X version 10.6 (a.k.a. Snow Leopard) – click the Apple icon on the menu bar, then click “About this Mac.” Unfortunately, I’m not aware of a way to run iPhone Simulator on 10.5 (Leopard).

1. Register as an Apple Developer (if you haven’t already)
2. Follow links to “iPhone SDK.” If you are already logged in, this link will take you there.
3. Click a link similar to “Xcode 3.2.3 and iPhone SDK 4” to download the SDK. It is a large file, so have your newspaper or knitting at the ready.
4. Once the download is complete, expand and install it.

Unfortunately, the iPhone Simulator is difficult to find. Here’s how to add it to your Applications folder:

1. Open Finder
2. Press Command+Shift+G and enter “/Developer/Platforms/iPhoneSimulator.platform/Developer/Applications/” in the blank. This will take you directly to the folder containing “iPhone Simulator.app”
3. Control+click on “iPhone Simulator.app” and click “Make Alias”
4. Single-click on the alias and press the Return key. Type “iPhone Simulator” to rename the alias and press Return.
5. Drag the alias and drop it on the Applications folder in your dock.

Now you can easily run iPhone Simulator from your Applications folder. For a great article describing how to use it, see Using iPhone Simulator from the iPhone Development Guide.

Please comment if these instructions don’t work for you.

Tip: take it offline

It seems like each day there’s more “urgent” demanding my attention at work. Finding quiet time to think, read and write has been a challenge. Perhaps you can relate.

So this past week I started blocking off 8-9 each morning as thinking time. But I’m so used to jumping from one thing to another that it’s hard to focus. Instead of writing a full draft of what I’m working on, I’ll get distracted hunting for examples online or looking up words in the thesaurus.

Sometimes a simpler interface makes all the difference — in this case, a move from keyboard to paper and pen. And to help me stay on track, I set a timer for 10 minutes of “no computer” time. By then I’m in the zone and well on my way.