2013 done. 1st quarter of 2014, done. The figures are still showing a favour toward m-commerce. This surpasses retail and e-commerce as well.

More than half of all the time spent with online retail in  2013 occurred on a mobile device. Almost a quarter of that was from a tablet device.

Retailers are experiencing some interesting challengers from shoppers. Shoppers will start using phones for price discovery, product comparison and reviews. It also blurs the lines between shopping, smartphone-initiated payments, social networking and sharing.

The mobile Internet traffic is increasing at lightning speed. It is now becoming crucial for retailers to embrace and invest in creating mobile platforms to capture greater market share in this space.



Another first for the Isle of Man by Fuzzelogic solutions

Blackberry is on the verge (30th Jan 2013) of launch their new devices and the new BBos10. We’ve been so fortunate to have worked with this OS.  Fuzzelogic solutions brings you another first for the Isle of man. The first company to offer BB os 10 development.

I’ll be posting the technical details of working with this os and the device + tool set etc at a later date.

Late nights, lots of docs, new experiences and some pretty innovative solutions – I want to thank our team for this.

Thanks everyone!

Heads up ! ios 6 + safari

Hi all!
just a quick heads up on iOS 6 and safari – seems to be causing an interesting issue.  It seems to be caching Ajax post requests. So keep an eye out for this. It is the safari + ios6 combo. so ios 6 + chrome is fine.

This typical ajax will now  be the culprit for a few hair pulls.

   type: "POST",
   url: "somePage.php",
   data: "name=John&location=Boston",
   success: function(msg){

There’s a couple ways to solve this and the right solution depends on the site and configuration.

  • add time stamping to the methods
  • add cache “no” parameters
  • update IIS for cache control
  • change the POST to GET
So – please let me know if you find other fixes :)
Lets share and beware !

MSBuild – build automation : part 2

Continuing on with MSBuild as a build automation system, there’s a few fundamentals to be aware of.

  • PropertyGroup : containing Properties. These are referenced using $(PropertyName) : from Microsoft: Properties are key/value pairs that can be used to configure builds. Properties are useful for passing values to tasks, evaluating in conditions, and storing values that will be referenced thoughout the project file.
  • ItemGroup: containing Items. These are referenced using @(ItemName) : from Microsoft: Items represent inputs into the build system that are grouped into item collections based on their user-defined collection names. These item collections can be used as parameters for tasks, which use the individual items contained in the collection to perform the steps of the build process.
  • Targets: These conain the Tasks to execute. : from Microsoft: Targets group tasks together in a particular order and allow sections of the build process to be called from the command line. Targets are often grouped into logical sections to allow for project file expansion and to increase readability. For example, one target may delete all files in the output directory to prepare for the build, while another compiles the inputs for the project and places them in the empty directory.
  • Task: The step to be executed/actioned. : from Microsoft: build platform needs the ability to execute any number of actions during the build process. MSBuild uses tasks to perform these actions. A task is a unit of executable code used by MSBuild to perform atomic build operations.

So lets put together what we have so far (from part 1), and put a basic build script together. Nothing too fancy just the standard hello world. A basic script that will output some text to the console window. First off, I usually create a batch file with the following in it :
%comspec% /k “”c:\Program Files\Microsoft Visual Studio 9.0\VC\vcvarsall.bat”" x86. This would allow us to run the msbuild file from our current location. Next off, Visual studio is about the best editor for the build file. It provides much needed intellisense support. You can use any text editor, Notepad, Notepad ++ etc.

So fire up the editor and churn out the bits below. First off, put in the xml declaration and Project node. Notice the DefaultTargets. This points to the Target that must be called to start off with. Next off, we add the Property group with  a single property. This will contain the text we want to output. Create the Target node and name it go. MsBuild offers a host of prebuild Tasks and one of them we will use is Message task.  Save this file in the same folder as the startup batch script. Call it helloworld.buildFile.

<?xml version=”1.0″?>
<Project xmlns=”http://schemas.microsoft.com/developer/msbuild/2003″ DefaultTargets=”go”>
<text_to_print>Hello msbuild World .. </text_to_print>
<Target Name=”go” >
<Message Text =”$(text_to_print)” />

To run this, fire up the batch file (the one from above), then at the command prompt type in  msbuild helloworld.buildFile.

results from hello world

results from hello world

MSBuild – build automation : part 1


I’m starting a series on build automation using msbuild. This will cover topics including the basics of msbuild, advanced topics using extensions, custom tasks and using msbuild as a deployment tool.

Why MSBuild?

Well, the simple answer. Its already there, its a build system maintained by Microsoft and keeps up to date with the latest version of .net.


Like with everything else, for a robust build system to work, it takes some planning.

  • Project layout – this will allow us to traverse the directory structure.
  • Build requirements – Do we want to build in Debug/release both?? Do we want to run tests??
  • Naming convention – come up with a meaningful naming convention.

The Basics

Ok, so the basics of msbuild. MSBuild is a Microsoft build platform shipped with the .net framework. Version 3.5 of MSBuild, which is bundled together with .NET 3.5 (and Visual Studio 2008), allows .NET projects to be built for either 2.0, 3.0 or 3.5 .NET version support (so called “multi-targeting”).

It is possible to build Visual Studio projects and solutions without the Visual Studio IDE installed and MSBuild is available at no cost.

Its based on an XML syntax, so we start with ..

<?xml version=”1.0″ encoding=”utf-8″?> next we add in the project tag. This encloses all the targets, properties and items required for the build. In adition to the namespace declaration, there’s 3 additional attributes worth noting. InitialTargets, ToolsVersion and DefaultTargets.

Xmlns : Required attribute.The xmlns attribute must have the value of “http://schemas.microsoft.com/developer/msbuild/2003″.

ToolsVersion: sets a target .NET Framework version to build the project with.Optional attribute

DefaultTargets: the default target(s) to run. Optional attribute. If no default target is specified in either the DefaultTargets attribute or the MSBuild command line, the engine executes the first target in the project file after the Import elements have been evaluated.

InitialTargets:runs before the targets specified in the DefaultTargets Optional attribute

<Project  xmlns=”http://schemas.microsoft.com/developer/msbuild/2003″ InitialTargets=”runs_before_the_default”

When specifying targets you can seperate multiple targets using a semicolon. The project file contains Property Groups, Item Groups and Targets. Targets contain a collection of executable tasks.

In the next post we’ll put all this together on a typical project.