Brewing a delicious cup of coffee is both an art and a science. Everyone starts from the holy grail of 60g to a litre of water (science). Beyond that, you’re a bit on your own. You start worrying about quite a few variables (art).

To make this slightly easier, some good souls (coffee roasters/baristas) have published recipes. These are based on a specific brewing method and honed through daily practice and customer turnover.

But recipes do run short as they’re based on a set of assumptions!

Two key assumptions are the kettle aka water temperature and your grind - they’re the base for a good extraction. Funnily enough, most recipes get them wrong. They’re either vague, or downright missing.

To help you get the most out of your awesome beans, I’m going to walk you through a couple of V60 recipes. I’ll showcase tips on how to deal with the vagueness including tools that will help.

Here

Let’s jump right in! I’m going to flesh out a smoke test that verifies our mobile sign in process works.

The test is written using Mocha.js and runs on Node.js. While working through the assertions, I’ll explain how Appium works. I’ll then verify the build on iOS/Android emulators as well as physical devices too!

You can review all the code in this post at my Appium smoke test bootstrap project. As a bonus, its includes both a detailed README to help you easily setup your environment and the sample app builds I’ll be testing against in this post.

The assertions

I should have an email field

To sign in, the app uses email as ID. My first assertion simply checks the existence of an email field.

it("should have an email field", function () {
    return driver
      .elementByCss('input[type=\'email\']', 500)
      .should.eventually.exist;
});

I should have a password field

My...

This is a recipe to help you automatically setup your iOS deployment target. In this case, amending the setting of a Cordova/PhoneGap generated project to iOS7+.

It’s part of my upcoming recipes book that helps you easily deploy your Cordova apps. Do sign up here for updates!

Automation is ideal as it prepares our project for a Continuous Integration flow. You can constantly recreate a platform with the confidence that it has been configured correctly. We’ll be scripting our Cordova hooks using the mighty NodeJS.

Hooking the hooks

Hooks live in a hooks directory under the main project folder. We target the after_platform_add CLI event so the adjust_ios_deploy_target.js script is added to a similarly named folder.

| Project /
|+ hooks /
|++ after_platform_add /
|+++ 001_adjust_ios_deploy_target.js

The 001_ file prefix preserves the running order in a hooks directory. Also, hooks...

99 problems

Houston, we have a problem! It’s failing, our app is constantly breaking UAT - but nothing has changed. Apart from we now build from JS and generate our iOS platform project on the fly. Could that be it? Why would that be it???

Damn Cordova, we should’ve just gone native. At least we could’ve relied on more solid documentation!!

After a day of frustration and digging it turns out the culprit is our base SDK set up. Previously, we were configured to run on iOS7+. This gave us the latest and greatest from Safari. Bizarrely, we’re now on a base of iOS5+.

Wat! and with dynamic builds how in the name of Steve Jobs can we make sure we’re always configured correctly!

The leaky abstraction

This scenario happens all the time. With Cordova and PhoneGap apps your constantly tweaking something or other in the underlying native platform. Its a very leaky abstraction. Some settings...

In this series I’ll be uncovering the various techniques and tools that can help you get started to manually test a mobile web or hybrid app.

Manual testing is a great way for verifying layouts and basic functionality. Automated tests afford us more verification but require a different set of tools and deeper understanding that’s not part of this series.

In [part 1](how-can-i-test-my-responsive-mobile-app-part-1), we tested with online and browser plug-ins to capture bugs.

In [part 2](how-can-i-test-my-responsive-mobile-app-part-2), we focused on emulators and mobile web apps.

Part 3, we shift our focus to hybrid mobile apps covering,

• Setting up a Cordova based app.
• Testing with a local iOS simulator.
• Testing with a local iOS simulator minus Xcode.
• Testing with a local Android emulator minus Eclipse.
• Workarounds for testing with cloud based emulators.

This post is great for...

My home setup (Aeropress, scales, thermometer & cheap grinder)

I love coffee, a lot. Luckily, I live in London town where the current crop of brilliant cafe’s and roasters has left me spoilt for choice. I’ve sampled the basics from the likes of Monmouth all the way to the ultra refined from Prufrock, Dunne Frankowski and Workshop to name a few.

I’ve nurtured a taste for the humble filter coffee. Actually, humble is a major understatement as the flavours are as complex as vintage wine. Brewing a filter is a delicate business something that a Hario V60, Kalita Wave and the awesome Chemex do really well. Not to mention the clean finish that you get from Siphon brews.

Aeropressed

However, when it comes to taste the only device that has genuinely captured my imagination is the clever, simple and durable Aeropress!

I have been procrastinating about buying one for well over a year now...

The manual testing series

In this series I’ll be uncovering the various techniques and tools that can help you get started to manually test a mobile web or hybrid app. Manual testing is a great way for verifying layouts and basic functionality. Automated tests afford us more verification but require a different set of tools and deeper understanding that’s not part of this series.

In [part 1](how-can-i-test-my-responsive-mobile-app-part-1), we tested with online and browser plug-ins to capture bugs.

Part 2, delves into testing on emulators specifically for mobile web apps running from the web. We’ll cover,

• Screenshot based tests.
• Testing with cloud based emulators.
• Testing with a local iOS based emulator aka simulator.
• Testing with a local Android emulator

Embracing devices

The layout of a page is influenced by more than just the width settings assigned to a media query. Testing...

The manual testing series

In this series I’ll be uncovering the various techniques and tools that can help you get started to manually test a mobile web or hybrid app. Manual testing is a great way for verifying layouts and basic functionality. Automated tests afford us more verification but require a different set of tools and deeper understanding that’s not part of this series.

Part 1, starts with examining responsive design and the simplest tests that can help us ensure all is well. Specifically,

• Testing online using viewport resizing sites.
• Testing with viewport resizing browser plug-ins.

How responsive?

Media queries afford us the capability to adapt our layout using a variety of parameters. The most commonly used parameter is width, specifically playing around with width ranges. You see this in the wild a lot especially as implemented by a multitude of css frameworks like...