Greg Howard from Aviator Man Magazine said, "Cars are exactly the same as planes and because we understand planes really well, we think we should have a say about cars and importantly, autonomous technology in cars. Autopilot systems on planes are pretty similar, there are lines in the road just like clouds in the sky and just like the sky, you never know when a BMW or Audi driver will cut you up and you have to be ready to take control in that situation."

Greg went on to say that while he thinks technologies like Tesla's Autopilot are good, they should only be switched on when your car is above 35,000 feet for safety reasons. This is another voice in the growing crowd of people who are backing more regulation for the car industry at a time when properly administered autonomous driving technologies have been proven to have killed zero people so far.

Greg says, "That's already way too many and it may be time to engage a knee jerk reaction that is needed to help save future drivers from themselves, and other aircraft."

If you happen to be considering purchasing a Tesla (the world's most awesome car) you now have an opportunity to get a £750 / $1,000 discount. Tesla are currently running a referral programme and offering buyers using the referral code a credit towards their new vehicle.

If you want to purchase a Tesla, you can use my referral code here: Tesla Motors Referral

This services allows us to automatically stay up to date with changes to dependencies without manually running through new versions ever time a dependency changes.

You can check out GreenKeeper here.

UPDATE! It's now at 63,000 a month! :)

ForerunnerDB's first commit was on 7th February 2014. Two years on and it is now a highly popular JavaScript database solution receiving over 42,000 downloads a month on NPM alone!

This is a landmark in our quest to create the best browser-based JSON database system available. Thank you to all of you who have downloaded and used ForerunnerDB, we hope it has made your life easier and your projects more enjoyable to code!

Geospatial queries allow you to find documents that are tagged with longitude / latitude coordinates by distance from a centre point.

ForerunnerDB will return results ordered by distance from the centre point, closest first. Geospatial indexing in ForerunnerDB takes the longitude and latitude coordinates in a document and converts them to an internal geohash. Geohashes are then used inside a b-tree to query nearby hashes in a performant manor.

Geospatial queries will only work on collections with a geospatial (2d) index.

You can read the ForerunnerDB manual to find out more about geo-spatial queries here: https://github.com/Irrelon/ForerunnerDB/tree/master#geospatial-2d-queries

I had ZWay working fine on an older version of Ubuntu of but I wanted to install a supported version (Ubuntu 14.04) but after installing a clean Ubuntu 14.04 then running the install for ZWay I found it was horribly broken.

There appears to be little or no information about getting ZWay installed on Ubuntu or Debian other than a little snippet on the ZWay installation page:

Z-Way for RaZberry is supported on Raspbian distribution for Raspberry Pi computer. Although it can be launched on other Raspberry Pi distributions too.

It turns out what this means is you need to manually download a debian version and then manually set it up.

So:

Install some dependencies first:

apt-get -y update
sudo apt-get -qy install libxml2 libarchive-dev curl
sudo apt-get -qy install sharutils tzdata gawk
sudo apt-get -qy install libavahi-compat-libdnssd-dev

Link a dependency with newer name:

sudo ln -s /usr/lib/x86_64-linux-gnu/libarchive.so.13 /usr/lib/x86_64-linux-gnu/libarchive.so.12

Go to http://razberry.z-wave.me/z-way-server and download the latest version 2.0.1 to your server, I used http://razberry.z-wave.me/z-way-server/z-way-server-Ubuntu-v2.0.1.tgz

I tried ALL other versions including later ones and NONE worked. Only 2.0.1 would work!

UPDATE I was able to get the newer versions 2.1.1 and 2.1.2-rc17 working but I had to contact zwaveeurope.com (the retailer of my UZB stick) and request a new license key. After starting 2.1.1 and entering the new key into zway, I was able to get it working. Version 2.1.2-rc17 also worked after the new key was entered.

Get the file:

wget http://razberry.z-wave.me/z-way-server/z-way-server-Ubuntu-v2.0.1.tgz

Untar the zip file:

sudo tar -zxf z-way-server-Ubuntu-v2.0.1.tgz -C /opt/

Create a service installer file:

nano install-service.sh

Paste the below text into it:

#!/usr/bin/env bash

# Create Z-Way startup script
echo "Creating Z-Way startup script"  
echo '#! /bin/sh  
### BEGIN INIT INFO
# Provides:          z-way-server
# Required-Start:
# Required-Stop:
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: Z-Way service
# Description:       Start Z-Way server for to allow comms with Z-Wave devices
### END INIT INFO

# Description: Z-Way server
# Author: Rob Evans <rob@irrelon.com>

PATH=/bin:/usr/bin:/sbin:/usr/sbin  
NAME=z-way-server  
DAEMON_PATH=/opt/z-way-server  
PIDFILE=/var/run/$NAME.pid

# adding z-way libs to library path
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/opt/z-way-server/libs

case "$1" in  
  start)
    echo -n "Starting z-way-server: "
    start-stop-daemon --start  --pidfile $PIDFILE --make-pidfile  --background --no-close --chdir $DAEMON_PATH --exec $NAME > /dev/null 2>&1
    echo "done."
    ;;
  stop)
    echo -n "Stopping z-way-server: "
    start-stop-daemon --stop --quiet --pidfile $PIDFILE
    rm $PIDFILE
    echo "done."
    ;;
  restart)
    echo "Restarting z-way-server: "
    sh $0 stop
    sleep 10
    sh $0 start
    ;;
  save)
    echo "Saving z-way-server configuration"
    PID=`sed s/[^0-9]//g $PIDFILE`
    /bin/kill -10 $PID
    ;;
  *)
    echo "Usage: /etc/init.d/z-way-server {start|stop|restart|save}"
    exit 1
    ;;
esac  
exit 0' > /etc/init.d/z-way-server  
chmod +x /etc/init.d/z-way-server

# Add z-way-server.log to logrotate
echo '/var/log/z-way-server.log {  
        daily
        size=10M
        rotate 4
        compress
        nodelaycompress
        missingok
        notifempty
        postrotate
            /usr/bin/killall -HUP z-way-server 2>/dev/null || true
        endscript
}' > /etc/logrotate.d/z-way-server

# Add Z-Way to autostart
echo "Adding z-way-server to autostart"  
update-rc.d z-way-server defaults  

Now run the service installer:

sudo bash install-service.sh

To check for any issues and see debug output you should manually launch z-way-server and look at the debug log on screen for any issues. To do that you can run (in the z-way-server folder):

cd /opt/z-way-server
LD_LIBRARY_PATH=libs ./z-way-server

Once you are satisfied everything is working by navigating to your server's IP under port 8083, you can start your z-way-server service via:

sudo service z-way-server start

Enjoy!

If you're anything like me, keeping track of every little snag with your new home can become a difficult and time consuming process. Sometimes you'll walk into a room and see a snag that you just keep forgetting to report to your developer but don't have time to call and log.

Once your developer does start to fix your snags you can run into other issues like remembering the exact conversation and what work was agreed.

Wouldn't it be better to have all this logged and tracked automatically, with a history log for each snag issue easily brought up when it was needed?

SnagBook is Your New Friend

With SnagBook, keeping track of your new home snagging issues is easy. Logging new snags is a simple process, and viewing a snag's history is effortless.

SnagBook is FREE to use and there are no charges or subscription fees EVER.

Furthermore, each snag can be automatically reported to your developer meaning no more annoying phone calls to describe your problem. When your developer is ready to fix your snag you get sent a notification and details of the fix, along with a schedule of when it will be done.

Logging, communicating and getting a response to your snags is now a simple affair. Check it out!

http://www.snagbook.co.uk

For example if you want to publish with the tag "beta" you would type:

npm publish --tag beta

The version you have just published will be registered under the beta tag rather than the latest tag, and will not be installed when someone attempts to install your package with the npm install command.

You can install different tagged versions using the npm install --tag command. For instance to install ForerunnerDB's dev version:

npm install forerunnerdb --tag dev

What is Synchronous Code?

When coding in JavaScript it is very common to see code with callbacks. This allows a process to go off, do something lengthy or time consuming and then callback when complete.

doSomethingLengthy(function (a) {
    console.log(a);
});

Synchronous code by comparison flows naturally from one line to the next without any callbacks. It looks like this:

var a = doSomethingLengthy();
console.log(a);

The sync version of the code has a problem though... it will block execution until doSomethingLengthy() is complete. In a browser this will mean the UI locks up and the user is left with a poor experience.

Callback-based code does not block execution but your code is less readable by another human. If your app is slightly more complex you can have callbacks inside callbacks inside more callbacks.

SyncScript Solves This

SyncScript is JavaScript but adds another keyword that allows you to write synchronous code that executes like callback-based code. SyncScript works in all JavaScript compatible browsers and environments and is 100% JavaScript compatible, requires no extra libraries or downloads and does not need a separate runtime.

All libraries, all plugins and all existing code works without issue with SyncScript.

SyncScript code looks like this:

var a = sync(doSomethingLengthy());
console.log(a);

Passing Multiple Arguments

Let's say we modify doSomethingLengthy() to require some arguments... now the defintion of doSomethingLengthy() is:

var doSomethingLengthy = function (url, flags, callback) {
    // Do some lengthy stuff

    // Lengthy stuff done, callback
    callback('moo');
};

SyncScript will work with this too:

var a = sync(doSomethingLengthy(
    'http://www.irrelon.com', { flag1: true }
));

When this call is done the value passed in the callback is assigned to 'a' so it now equals 'moo'.

Callback With Multiple Values

The above example is great if you only callback with a single value but what about passing back multiple values? That's pretty simple too, just declare multiple variables in the order they are passed back, before the call to sync(). Here is a more likely example:

var err, data = sync(doSomethingLengthy(
    'http://www.irrelon.com', { flag1: true }
));

Setting Callback Scope

You can section areas of code into distinct async calls that will execute in parallel by wrapping them in curly braces. Take the following code for example. The second call to addSync waits for the first to finish:

var err, myVal = sync(addAsync(1, 2, 3, 4));  
console.log(myVal);

var err, myVal = sync(addAsync(1, 2, 3, 4));  
console.log(myVal);  

What if you want both async calls to execute at the same time? You can achieve this by wrapping each call
and it's dependant code in braces:

{
    var err, myVal = sync(addAsync(1, 2, 3, 4));
    console.log(myVal);
}

{
    var err, myVal = sync(addAsync(1, 2, 3, 4));
    console.log(myVal);
}

Now both calls will execute and return in whichever order they complete in.

How SyncScript Works

SyncScript transpiles to an AST after which the tree is analysed, sync calls are identified and then the AST is modified to produce callback-based code where the sync calls are. After modification of the AST it is taken and re-compiled back into JavaScript.

Further Reading

You can read more about SyncScript and the future development roadmap, download and see usage instructions at https://github.com/irrelon/SyncScript

Almost every app you develop for Apple's iOS will need a way to detect if it has an internet connection or not. Using the Reachability class you can ask to be informed when the status of the internet connection changes, as well as what the status is when your app starts up.

In this tutorial I will explain how you can create a reachability system that allows you to check for internet connectivity at any point in your application's life-cycle.

The Code

Step 1: Include Reachablity

Reachability.h

/*
 Copyright (c) 2011, Tony Million.
 All rights reserved.

 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:

 1. Redistributions of source code must retain the above copyright notice, this
 list of conditions and the following disclaimer.

 2. Redistributions in binary form must reproduce the above copyright notice,
 this list of conditions and the following disclaimer in the documentation
 and/or other materials provided with the distribution.

 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
 */

#import <Foundation/Foundation.h>
#import <SystemConfiguration/SystemConfiguration.h>

#import <sys/socket.h>
#import <netinet/in.h>
#import <netinet6/in6.h>
#import <arpa/inet.h>
#import <ifaddrs.h>
#import <netdb.h>

/**
 * Does ARC support GCD objects?
 * It does if the minimum deployment target is iOS 6+ or Mac OS X 8+
 *
 * @see http://opensource.apple.com/source/libdispatch/libdispatch-228.18/os/object.h
 **/
#if OS_OBJECT_USE_OBJC
#define NEEDS_DISPATCH_RETAIN_RELEASE 0
#else
#define NEEDS_DISPATCH_RETAIN_RELEASE 1
#endif

/**
 * Create NS_ENUM macro if it does not exist on the targeted version of iOS or OS X.
 *
 * @see http://nshipster.com/ns_enum-ns_options/
 **/
#ifndef NS_ENUM
#define NS_ENUM(_type, _name) enum _name : _type _name; enum _name : _type
#endif

extern NSString *const kReachabilityChangedNotification;

typedef NS_ENUM(NSInteger, NetworkStatus) {  
    // Apple NetworkStatus Compatible Names.
    NotReachable = 0,
    ReachableViaWiFi = 2,
    ReachableViaWWAN = 1
};

@class Reachability;

typedef void (^NetworkReachable)(Reachability * reachability);  
typedef void (^NetworkUnreachable)(Reachability * reachability);

@interface Reachability : NSObject

@property (nonatomic, copy) NetworkReachable    reachableBlock;
@property (nonatomic, copy) NetworkUnreachable  unreachableBlock;


@property (nonatomic, assign) BOOL reachableOnWWAN;

+(Reachability*)reachabilityWithHostname:(NSString*)hostname;
// This is identical to the function above, but is here to maintain
//compatibility with Apples original code. (see .m)
+(Reachability*)reachabilityWithHostName:(NSString*)hostname;
+(Reachability*)reachabilityForInternetConnection;
+(Reachability*)reachabilityWithAddress:(const struct sockaddr_in*)hostAddress;
+(Reachability*)reachabilityForLocalWiFi;

-(Reachability *)initWithReachabilityRef:(SCNetworkReachabilityRef)ref;

-(BOOL)startNotifier;
-(void)stopNotifier;

-(BOOL)isReachable;
-(BOOL)isReachableViaWWAN;
-(BOOL)isReachableViaWiFi;

// WWAN may be available, but not active until a connection has been established.
// WiFi may require a connection for VPN on Demand.
-(BOOL)isConnectionRequired; // Identical DDG variant.
-(BOOL)connectionRequired; // Apple's routine.
                           // Dynamic, on demand connection?
-(BOOL)isConnectionOnDemand;
// Is user intervention required?
-(BOOL)isInterventionRequired;

-(NetworkStatus)currentReachabilityStatus;
-(SCNetworkReachabilityFlags)reachabilityFlags;
-(NSString*)currentReachabilityString;
-(NSString*)currentReachabilityFlags;

@end

Reachability.m

/*
 Copyright (c) 2011, Tony Million.
 All rights reserved.

 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met:

 1. Redistributions of source code must retain the above copyright notice, this
 list of conditions and the following disclaimer.

 2. Redistributions in binary form must reproduce the above copyright notice,
 this list of conditions and the following disclaimer in the documentation
 and/or other materials provided with the distribution.

 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 POSSIBILITY OF SUCH DAMAGE.
 */

#import "Reachability.h"


NSString *const kReachabilityChangedNotification = @"kReachabilityChangedNotification";

@interface Reachability ()

@property (nonatomic, assign) SCNetworkReachabilityRef  reachabilityRef;


#if NEEDS_DISPATCH_RETAIN_RELEASE
@property (nonatomic, assign) dispatch_queue_t          reachabilitySerialQueue;
#else
@property (nonatomic, strong) dispatch_queue_t          reachabilitySerialQueue;
#endif


@property (nonatomic, strong) id reachabilityObject;

-(void)reachabilityChanged:(SCNetworkReachabilityFlags)flags;
-(BOOL)isReachableWithFlags:(SCNetworkReachabilityFlags)flags;

@end

static NSString *reachabilityFlags(SCNetworkReachabilityFlags flags)  
{
    return [NSString stringWithFormat:@"%c%c %c%c%c%c%c%c%c",
#if    TARGET_OS_IPHONE
            (flags & kSCNetworkReachabilityFlagsIsWWAN)               ? 'W' : '-',
#else
            'X',
#endif
            (flags & kSCNetworkReachabilityFlagsReachable)            ? 'R' : '-',
            (flags & kSCNetworkReachabilityFlagsConnectionRequired)   ? 'c' : '-',
            (flags & kSCNetworkReachabilityFlagsTransientConnection)  ? 't' : '-',
            (flags & kSCNetworkReachabilityFlagsInterventionRequired) ? 'i' : '-',
            (flags & kSCNetworkReachabilityFlagsConnectionOnTraffic)  ? 'C' : '-',
            (flags & kSCNetworkReachabilityFlagsConnectionOnDemand)   ? 'D' : '-',
            (flags & kSCNetworkReachabilityFlagsIsLocalAddress)       ? 'l' : '-',
            (flags & kSCNetworkReachabilityFlagsIsDirect)             ? 'd' : '-'];
}

// Start listening for reachability notifications on the current run loop
static void TMReachabilityCallback(SCNetworkReachabilityRef target, SCNetworkReachabilityFlags flags, void* info)  
{
#pragma unused (target)
#if __has_feature(objc_arc)
    Reachability *reachability = ((__bridge Reachability*)info);
#else
    Reachability *reachability = ((Reachability*)info);
#endif

    // We probably don't need an autoreleasepool here, as GCD docs state each queue has its own autorelease pool,
    // but what the heck eh?
    @autoreleasepool
    {
        [reachability reachabilityChanged:flags];
    }
}


@implementation Reachability

@synthesize reachabilityRef;
@synthesize reachabilitySerialQueue;

@synthesize reachableOnWWAN;

@synthesize reachableBlock;
@synthesize unreachableBlock;

@synthesize reachabilityObject;

#pragma mark - Class Constructor Methods

+(Reachability*)reachabilityWithHostName:(NSString*)hostname
{
    return [Reachability reachabilityWithHostname:hostname];
}

+(Reachability*)reachabilityWithHostname:(NSString*)hostname
{
    SCNetworkReachabilityRef ref = SCNetworkReachabilityCreateWithName(NULL, [hostname UTF8String]);
    if (ref)
    {
        id reachability = [[self alloc] initWithReachabilityRef:ref];

#if __has_feature(objc_arc)
        return reachability;
#else
        return [reachability autorelease];
#endif

    }

    return nil;
}

+(Reachability *)reachabilityWithAddress:(const struct sockaddr_in *)hostAddress
{
    SCNetworkReachabilityRef ref = SCNetworkReachabilityCreateWithAddress(kCFAllocatorDefault, (const struct sockaddr*)hostAddress);
    if (ref)
    {
        id reachability = [[self alloc] initWithReachabilityRef:ref];

#if __has_feature(objc_arc)
        return reachability;
#else
        return [reachability autorelease];
#endif
    }

    return nil;
}

+(Reachability *)reachabilityForInternetConnection
{
    struct sockaddr_in zeroAddress;
    bzero(&zeroAddress, sizeof(zeroAddress));
    zeroAddress.sin_len = sizeof(zeroAddress);
    zeroAddress.sin_family = AF_INET;

    return [self reachabilityWithAddress:&zeroAddress];
}

+(Reachability*)reachabilityForLocalWiFi
{
    struct sockaddr_in localWifiAddress;
    bzero(&localWifiAddress, sizeof(localWifiAddress));
    localWifiAddress.sin_len            = sizeof(localWifiAddress);
    localWifiAddress.sin_family         = AF_INET;
    // IN_LINKLOCALNETNUM is defined in <netinet/in.h> as 169.254.0.0
    localWifiAddress.sin_addr.s_addr    = htonl(IN_LINKLOCALNETNUM);

    return [self reachabilityWithAddress:&localWifiAddress];
}


// Initialization methods

-(Reachability *)initWithReachabilityRef:(SCNetworkReachabilityRef)ref
{
    self = [super init];
    if (self != nil)
    {
        self.reachableOnWWAN = YES;
        self.reachabilityRef = ref;
    }

    return self;
}

-(void)dealloc
{
    [self stopNotifier];

    if(self.reachabilityRef)
    {
        CFRelease(self.reachabilityRef);
        self.reachabilityRef = nil;
    }

    self.reachableBlock     = nil;
    self.unreachableBlock   = nil;

#if !(__has_feature(objc_arc))
    [super dealloc];
#endif


}

#pragma mark - Notifier Methods

// Notifier
// NOTE: This uses GCD to trigger the blocks - they *WILL NOT* be called on THE MAIN THREAD
// - In other words DO NOT DO ANY UI UPDATES IN THE BLOCKS.
//   INSTEAD USE dispatch_async(dispatch_get_main_queue(), ^{UISTUFF}) (or dispatch_sync if you want)

-(BOOL)startNotifier
{
    SCNetworkReachabilityContext    context = { 0, NULL, NULL, NULL, NULL };

    // this should do a retain on ourself, so as long as we're in notifier mode we shouldn't disappear out from under ourselves
    // woah
    self.reachabilityObject = self;



    // First, we need to create a serial queue.
    // We allocate this once for the lifetime of the notifier.
    self.reachabilitySerialQueue = dispatch_queue_create("com.tonymillion.reachability", NULL);
    if(self.reachabilitySerialQueue == nil)
    {
        return NO;
    }

#if __has_feature(objc_arc)
    context.info = (__bridge void *)self;
#else
    context.info = (void *)self;
#endif

    if (!SCNetworkReachabilitySetCallback(self.reachabilityRef, TMReachabilityCallback, &context))
    {
#ifdef DEBUG
        NSLog(@"SCNetworkReachabilitySetCallback() failed: %s", SCErrorString(SCError()));
#endif

        // Clear out the dispatch queue
        if(self.reachabilitySerialQueue)
        {
#if NEEDS_DISPATCH_RETAIN_RELEASE
            dispatch_release(self.reachabilitySerialQueue);
#endif
            self.reachabilitySerialQueue = nil;
        }

        self.reachabilityObject = nil;

        return NO;
    }

    // Set it as our reachability queue, which will retain the queue
    if(!SCNetworkReachabilitySetDispatchQueue(self.reachabilityRef, self.reachabilitySerialQueue))
    {
#ifdef DEBUG
        NSLog(@"SCNetworkReachabilitySetDispatchQueue() failed: %s", SCErrorString(SCError()));
#endif

        // UH OH - FAILURE!

        // First stop, any callbacks!
        SCNetworkReachabilitySetCallback(self.reachabilityRef, NULL, NULL);

        // Then clear out the dispatch queue.
        if(self.reachabilitySerialQueue)
        {
#if NEEDS_DISPATCH_RETAIN_RELEASE
            dispatch_release(self.reachabilitySerialQueue);
#endif
            self.reachabilitySerialQueue = nil;
        }

        self.reachabilityObject = nil;

        return NO;
    }

    return YES;
}

-(void)stopNotifier
{
    // First stop, any callbacks!
    SCNetworkReachabilitySetCallback(self.reachabilityRef, NULL, NULL);

    // Unregister target from the GCD serial dispatch queue.
    SCNetworkReachabilitySetDispatchQueue(self.reachabilityRef, NULL);

    if(self.reachabilitySerialQueue)
    {
#if NEEDS_DISPATCH_RETAIN_RELEASE
        dispatch_release(self.reachabilitySerialQueue);
#endif
        self.reachabilitySerialQueue = nil;
    }

    self.reachabilityObject = nil;
}

#pragma mark - reachability tests

// This is for the case where you flick the airplane mode;
// you end up getting something like this:
//Reachability: WR ct-----
//Reachability: -- -------
//Reachability: WR ct-----
//Reachability: -- -------
// We treat this as 4 UNREACHABLE triggers - really apple should do better than this

#define testcase (kSCNetworkReachabilityFlagsConnectionRequired | kSCNetworkReachabilityFlagsTransientConnection)

-(BOOL)isReachableWithFlags:(SCNetworkReachabilityFlags)flags
{
    BOOL connectionUP = YES;

    if(!(flags & kSCNetworkReachabilityFlagsReachable))
        connectionUP = NO;

    if( (flags & testcase) == testcase )
        connectionUP = NO;

#if    TARGET_OS_IPHONE
    if(flags & kSCNetworkReachabilityFlagsIsWWAN)
    {
        // We're on 3G.
        if(!self.reachableOnWWAN)
        {
            // We don't want to connect when on 3G.
            connectionUP = NO;
        }
    }
#endif

    return connectionUP;
}

-(BOOL)isReachable
{
    SCNetworkReachabilityFlags flags;

    if(!SCNetworkReachabilityGetFlags(self.reachabilityRef, &flags))
        return NO;

    return [self isReachableWithFlags:flags];
}

-(BOOL)isReachableViaWWAN
{
#if    TARGET_OS_IPHONE

    SCNetworkReachabilityFlags flags = 0;

    if(SCNetworkReachabilityGetFlags(reachabilityRef, &flags))
    {
        // Check we're REACHABLE
        if(flags & kSCNetworkReachabilityFlagsReachable)
        {
            // Now, check we're on WWAN
            if(flags & kSCNetworkReachabilityFlagsIsWWAN)
            {
                return YES;
            }
        }
    }
#endif

    return NO;
}

-(BOOL)isReachableViaWiFi
{
    SCNetworkReachabilityFlags flags = 0;

    if(SCNetworkReachabilityGetFlags(reachabilityRef, &flags))
    {
        // Check we're reachable
        if((flags & kSCNetworkReachabilityFlagsReachable))
        {
#if    TARGET_OS_IPHONE
            // Check we're NOT on WWAN
            if((flags & kSCNetworkReachabilityFlagsIsWWAN))
            {
                return NO;
            }
#endif
            return YES;
        }
    }

    return NO;
}


// WWAN may be available, but not active until a connection has been established.
// WiFi may require a connection for VPN on Demand.
-(BOOL)isConnectionRequired
{
    return [self connectionRequired];
}

-(BOOL)connectionRequired
{
    SCNetworkReachabilityFlags flags;

    if(SCNetworkReachabilityGetFlags(reachabilityRef, &flags))
    {
        return (flags & kSCNetworkReachabilityFlagsConnectionRequired);
    }

    return NO;
}

// Dynamic, on demand connection?
-(BOOL)isConnectionOnDemand
{
    SCNetworkReachabilityFlags flags;

    if (SCNetworkReachabilityGetFlags(reachabilityRef, &flags))
    {
        return ((flags & kSCNetworkReachabilityFlagsConnectionRequired) &&
                (flags & (kSCNetworkReachabilityFlagsConnectionOnTraffic | kSCNetworkReachabilityFlagsConnectionOnDemand)));
    }

    return NO;
}

// Is user intervention required?
-(BOOL)isInterventionRequired
{
    SCNetworkReachabilityFlags flags;

    if (SCNetworkReachabilityGetFlags(reachabilityRef, &flags))
    {
        return ((flags & kSCNetworkReachabilityFlagsConnectionRequired) &&
                (flags & kSCNetworkReachabilityFlagsInterventionRequired));
    }

    return NO;
}


#pragma mark - reachability status stuff

-(NetworkStatus)currentReachabilityStatus
{
    if([self isReachable])
    {
        if([self isReachableViaWiFi])
            return ReachableViaWiFi;

#if    TARGET_OS_IPHONE
        return ReachableViaWWAN;
#endif
    }

    return NotReachable;
}

-(SCNetworkReachabilityFlags)reachabilityFlags
{
    SCNetworkReachabilityFlags flags = 0;

    if(SCNetworkReachabilityGetFlags(reachabilityRef, &flags))
    {
        return flags;
    }

    return 0;
}

-(NSString*)currentReachabilityString
{
    NetworkStatus temp = [self currentReachabilityStatus];

    if(temp == reachableOnWWAN)
    {
        // Updated for the fact that we have CDMA phones now!
        return NSLocalizedString(@"Cellular", @"");
    }
    if (temp == ReachableViaWiFi)
    {
        return NSLocalizedString(@"WiFi", @"");
    }

    return NSLocalizedString(@"No Connection", @"");
}

-(NSString*)currentReachabilityFlags
{
    return reachabilityFlags([self reachabilityFlags]);
}

#pragma mark - Callback function calls this method

-(void)reachabilityChanged:(SCNetworkReachabilityFlags)flags
{
    if([self isReachableWithFlags:flags])
    {
        if(self.reachableBlock)
        {
            self.reachableBlock(self);
        }
    }
    else
    {
        if(self.unreachableBlock)
        {
            self.unreachableBlock(self);
        }
    }

    // this makes sure the change notification happens on the MAIN THREAD
    dispatch_async(dispatch_get_main_queue(), ^{
        [[NSNotificationCenter defaultCenter] postNotificationName:kReachabilityChangedNotification
                                                            object:self];
    });
}

#pragma mark - Debug Description

- (NSString *) description
{
    NSString *description = [NSString stringWithFormat:@"<%@: %#x>",
                             NSStringFromClass([self class]), (unsigned int) self];
    return description;
}

@end

Step 2: Include ConnectionStatus

ConnectionStatus.h

//
//  ConnectionStatus.h
//  Irrelon Software Limited
//
//  Created by Rob Evans on 02/03/2014.
//  Copyright (c) 2014 Irrelon Software Limited. All rights reserved.
//

#import <Foundation/Foundation.h>

@interface ConnectionStatus : NSObject

@property BOOL _connectionStatus;

+ (id)sharedInstance;
- (BOOL)isConnected;
- (void)setConnected:(BOOL)state;

@end

ConnectionStatus.m

//
//  ConnectionStatus.m
//  Irrelon Software Limited
//
//  Created by Rob Evans on 02/03/2014.
//  Copyright (c) 2014 Irrelon Software Limited. All rights reserved.
//

#import "ConnectionStatus.h"

@implementation ConnectionStatus

+ (id)sharedInstance {
    // structure used to test whether the block has completed or not
    static dispatch_once_t p = 0;

    // initialize sharedObject as nil (first call only)
    __strong static id _sharedObject = nil;

    // executes a block object once and only once for the lifetime of an application
    dispatch_once(&p, ^{
        _sharedObject = [[self alloc] init];
    });

    // returns the same object each time
    return _sharedObject;
}

- (id)init {
    self = [super init];

    if (self) {
        self._connectionStatus = false;
    }

    return self;
}

- (BOOL)isConnected {
    return self._connectionStatus;
}

- (void)setConnected:(BOOL)state {
    self._connectionStatus = state;
}

@end

Step 2: Update Your App Delegate .h

1: Add the Reachability.h and ConnectionState.h to your imports in your app delegate's .h file
2: Add a property "hostReachability" to the app delegate's properties
3: Add the "reachabilityChanged" method definition

#import <UIKit/UIKit.h>
#import "Reachability.h"
#import "ConnectionState.h"

@interface AppDelegate : UIResponder <UIApplicationDelegate>

@property (strong, nonatomic) UIWindow *window;
@property (strong, nonatomic) Reachability *hostReachability;

- (void)reachabilityChanged:(NSNotification *)notification;

@end

Step 3: Add Code to App Delegate .m

Add the following code into the "applicationWillEnterForeground" method AND the "applicationDidBecomeActive" method:

[self startReachabilityCheck];

Then add the startReachabilityCheck method to the app delegate .m:

- (void)startReachabilityCheck {
    // Check if we need to create a hostReachability instance
    if (self.hostReachability == nil) {
        // Create an instance of reachability
        self.hostReachability = [Reachability reachabilityForInternetConnection];

        // Listen for changes
        [[NSNotificationCenter defaultCenter] addObserver:self
                                                 selector:@selector(reachabilityChanged:)
                                                     name:kReachabilityChangedNotification
                                                   object:nil];
    }

    // Start notifications
    [self.hostReachability startNotifier];

    // Set the current reachability
    [[ConnectionState sharedInstance] setConnected:[self.hostReachability isReachable]];
}

Usage

Now that your app is set up to maintain a status of your internet connectivity you can check for a valid connection at any time in your app by importing "ConnectionStatus.h" and then using:

BOOL status = [[ConnectionStatus sharedInstance] isConnected];  

ForerunnerDB supports data-binding for realtime data-to-view linking, uses MongoDB's query language as its API and is the most advanced database available for your web app today.

Why not give it a spin over at http://www.forerunnerdb.com

Enjoy!

Up 'till now I've been using requirejs for modules but due to the pain it causes in development (and later deployment building) I have been searching for an alternative.

Hello Browserify

Browserify uses Node.js to compile your JavaScript source modules into a single file that you can include in your web pages.

It allows you to write code and modularise it very easily:

var MyModule = function () {  
    this._hello = true;
};

MyModule.prototype.hello = function (val) {  
    if (val !== undefined) {
        this._hello = val;
        return this;
    }

    return this._hello;
};

module.exports = MyModule;  

This module just defines a class we can instantiate that has a simple getter/setter method called "hello()".

In browserify to use this module you just require it:

var MyModule = require('./myModule.js'),  
    myModule;

myModule = new MyModule();  
myModule.hello('moo');  

Simple and painless modules! I suggest you give browserify a good run, it will speed up your development and make your life a lot simpler!

The require site and documentation can be a tad confusing / overcomplex for a new user so I wanted to write a quick tutorial to make require easy to understand.

File Structure

Our example file structure is:

• index.html
• /js
  • init.js
  • Car.js
  • Wheel.js

Include Require

<script src="require.js" data-main="js/init.js"></script>  

You'll notice the "data-main" attribute with the value "js/init.js". This data attribute tells require to load that script once require itself has loaded.

This allows you to have a single <script> tag that loads require.js and also specify a script to load to start your app, all in one tag.

App Entry Point

We've specified to require that we want to load the init.js file on startup so here's the contents of that file:

require(['Car'], function (Car) {  
    var car = new Car();
    car.drive();
});

You'll notice it calls "require()" instead of "define()"... that is because it doesn't provide any output, only describes what modules it needs.

Modules that don't provide anything can use require(). Modules that provide something use define();

Creating a Module

Every file in your app is a module that can require other modules and provide data for other modules that require it.

Let's look at defining a module called Car:

// Define a module with it's dependencies (Wheel)
define(['Wheel'], function (Wheel) {  
    var Car = function () {
        this.wheel1 = new Wheel();
        this.wheel2 = new Wheel();
        this.wheel3 = new Wheel();
        this.wheel4 = new Wheel();
    };

    Car.prototype.drive = function () {
        console.log('Brrroooommm!');
    };

    return Car;
});

The define call takes an array of modules that this module depends on, in this case the Wheel module, and then passes each module's return value as an argument in the function which is the second parameter.

The function is only called once all the dependencies are loaded.

Here's the Wheel module:

define([], function () {  
    var Wheel = function () {
        this._diameter = 10;
    };

    return Wheel;
});

That's all!

That should be all you need to setup and use require for your web app!

Say you have your player entity:

var player = new IgeEntityBox2d()  
    .id('player');

You have some enemies too:

var enemy = new IgeEntityBox2d()  
    .id('enemy1')
    .category('enemy');

You need to know when an enemy collides with your player. Using vanilla box2d you would register a contact listener, examine the contact for information about the two bodies that collided and then decide if a collision occurred.

In comparison with the new IGE update you can now do this:

player.on('collisionStart', '.enemy', function (contactData) {  
    // Do whatever you want here
});

You can also hook when a contact ends:

player.on('collisionEnd', '.enemy', function (contactData) {  
    // Do whatever you want here
});

You'll notice the '.enemy' selector in the call to "on()". This is the target selector that must match the entity being collided with for the event to fire. If you want to reference an entity via id instead of category, use the # symbol instead:

player.on('collisionStart', '#enemy1', function (contactData) {  
    // Do whatever you want here
});

Awesome! :) - Available now on the premium repo dev branch version 1.5.5.