Archive for March, 2012

Archive for March, 2012


Posted on

Business Growth Strategies
How to Select Your Fractional CMO

Step 1
Discovery Call
At your convenience, Chief Outsiders will set a time for you to share your unique challenges and opportunities for growth

Step 2
CMO Match
We help match your situation and requirements to one or more fractional CMOs, facilitating your selection to ensure you’ll get the right expertise plus a good cultural fit

Step 3
Statement of Work
We develop a customized statement of work to achieve the desired outcomes with agreed to timeframes and costs

Step 4
Quick Start
Your CMO gets started in days, working month to month, without a long-term commitment

Business growth strategies start with market insights. While research firms and strategic marketing consultants can bring these insights to bear on an ad-hoc basis, companies committed to growth will develop systems and processes to ensure a continuous flow of market insights into their business. Talk to us about taking your business to the next level.

Watch and listen to Alan Taylor and Art Saxby, Chief Outsiders CEO, discuss Business Growth Strategy at the Inc 5000

New Product/Service Strategy Development
Perhaps the most obvious source of growth or revenue maintenance is the development of new offerings to your existing customer base. Staying close to emerging customer requirements is straight-forward when there is good communication from sales and support teams. Keeping customers involved in reviewing product roadmaps and helping to prioritize features (as well as confirming value and appeal) are keys to the process.

Market Expansion Strategy
Product Diversification Strategy
Market Opportunity Analysis
Competitive Market Analysis
Market Segmentation Strategy
Market Expansion Strategy
Learning how to expand your target markets – whether by customer type or geographic location – is often business growth strategies matrixthe linchpin for sustained growth. This requires a synchronization of operational capabilities and marketing to assure the market expansion strategy is viable and can actually be implemented. New market knowledge is critical to success, and consists of developing insights from target customers, assessing relevance and appeal versus competitive offerings, understanding the sales process and other offering delivery requirements. Maintaining clarity of the strategy just across the executive team, let alone the company, can be a huge task when the expansion strategy requires the company to reposition itself, learn more about asynchronous collaboration benefits.

Product Diversification Strategy
Diversifying your product portfolio can lead to expanding your share of wallet with your customer base, as well as make your offerings appeal to a broader market base. The key is tying product development resources (engineering, product management, etc.) to real customer requirements and maintaining the customers’ perspectives of wants, needs and usages throughout the development process. Alpha and beta testing with customers is essential before finalizing go-to-market plans.

Market Opportunity Analysis
Related to a market expansion strategy as well as product diversification, a market opportunity analysis can be used to flesh out potential ideas. The very notion suggests that a company is more interested in a market perspective than its own often-assumptive perspective. The scope of such analysis can range from straight forward and short-term, to expansive and longer term. An initial sense of what’s at stake may call for patience in conducting the more comprehensive study. Or, competitive pressures may drive a company to quickly complete its assessment. The outcome should include: target markets (by type and geography), current solutions assessments (how problems are being solved today), an extrapolation of solutions scenarios (often driven by forecasting the impact of technology and other economic drivers).

Competitive Market Analysis
In a crowded market (some refer to this as a red ocean), competitive intelligence is critical to both operational and strategic decision making. A rigorous and regular approach to competitive position, direction, and strengths and weaknesses can help senior executives identify gaps and opportunities. The implications and usages for such learnings can be highly strategic (what new markets or segments should be pursued) to very tactical (what messaging will better position our offerings in our on-going promotional activity.

Market Segmentation Strategy
Segmenting markets, targets and opportunities can yield greater clarity and more specific relevance for a company and its offerings. In some cases the same product can be repositioned to be made more relevant to a segment. In other cases, a solid market segmentation strategy will help justify new market entries and product development. This activity always leads to greater insights and clarity for how a company can serve its current and potential markets.

Haskell for Rubyists

Posted on

In the last year I’ve been playing with a new language: Haskell. I have found it to be a very suitable second high-level language for me as a Rubyist, and in this post I will explain (with examples!) some of why I, as a Rubyist, love Haskell, and how you can use it to do awesome things.

Why Another Language?

One thing I wasn’t sure about for a long time was if I even needed another language. Obviously, being able to work in any environment you have thrown at you is an essential job skill, but I mean a language I chose for myself. I am a Rubyist, do I need to be anything else?

Well, while I love Ruby, there are a few reasons I eventually chose to go in search of a second language to call my own:

  1. Performance

    Ruby implementations are getting faster all the time, but we all know there are faster things out there. It’s the reason some things (like the JSON gem) have versions written in C. I felt it would be nice for some tasks to get the performance boost that comes from an optimising compiler, without having to drop all the way to C.

  2. Portability

    Yes, Ruby is super-portable… to systems that have a ruby implementation. It’s somewhat complex to just email arbitrary users a ruby script and hope they can use it without setup help.

  3. Linking with native code

    Ruby extensions and FFIs exist so that we can call C code from Ruby. What about calling Ruby code from C or another language? It can be done, but only if most of MRI is linked in to the target and the Ruby is more-or-less “eval’d”.

In case you haven’t guessed, basically I wanted a nice high-level environment like Ruby, but with a native code output.

Isn’t Haskell Hard?

No. Or at least, not harder than any other language. It is true that the Haskell community has a higher-than-average concentration of Ivory Tower Dwellers. Yes, some of them have been in the Tower for so long that they have forgot how to write anything but symbols from higher-order logics. Yes, the documentation for some really nice Haskell libraries and features are dense academic papers. Don’t let them scare you off. There are humans in the community as well, and # on freenode IRC has many of them.

Type Inference

One of the nice features of Ruby is the type system. If you’re used to un-inferred static typing (read: C) then the ability to write code like this:

def fun(a, b); (a + b) * 3; end

is liberating. Haskell has a static type system, which means that you’ll never have a program crash in production because you’re passing in different data than you though, but only in a case your tests didn’t catch. Unlike C, however, Haskell’s system is strong (which means that data is not magically cast for you, so you get stronger guarantees, just like how in Ruby we must write 1.to_s + "hello" not 1 + "hello"), but more importantly it is inferred, so the equivalent of the above in Haskell is:

fun a b = (a + b) * 3

You can add type annotations (like in C) if you want to, which sometimes helps for clarity, but you don’t need to.

The only limitation here is that data structures are mostly of a single type, for example in Ruby:

a = [1, "hello"]

is perfectly fine. This is sometimes a good thing, and sometimes causes strange bugs. In Haskell, this would be an error, so we need to define unions explicitly:

data StuffInMyList = I Integer | S String
a = [I 1, S "hello"]

A small pain, but I feel it’s a fine trade-off.


The mixin module is one of the defining characteristics of Ruby. Haskell has something similar, called Typeclasses, which form the foundation of polymorphism in the language. In Ruby:

module Equality
def equals?(b); self == b; end

class Thing
include Equality

In Haskell:

class (Eq a) => Equality a where
	isEqual :: a -> a -> Bool
	isEqual x y = x == y

data Thing = Thing deriving (Eq)

instance Equality Thing

This looks a bit different. You’ll note I had to give a type signature to the isEqual function. This is one of the few places you have to, and it has to do with making the polymorphism we get with mixins a bit safer. My Equality mixin has to be restricted to types from the Eq typeclass (because I use == on them), which is also true in Ruby except that in Ruby every single class has == defined.

Significant Whitespace

Haskell has significant whitespace. If you’re a Rubyist on the run from Python this may scare you, but there are two reasons this does not bother me. First, the Haskell whitespace is much nicer than in Python, and the way code gets written in Haskell you rarely have the “where does this huge block end?” problem. Second, the whitespace in Haskell is optional! Here’s that typeclass again, but without the whitespace use:

class (Eq a) => Equality a where { isEqual :: a -> a -> Bool; isEqual x y = x == y; }


Let’s see a real example!

You may have heard that Haskell I/O is weird, and that Haskell has no access to mutation. While Ruby code is often non-destructive in nature itself, access to mutation is sometimes handy. Understanding why Haskell I/O is safe and such is not terrible, but it does take learning a new concept (called Monads, with roots in those academics, but there are good simple explanations out there without too much math, like in Learn You a Haskell (for Great Good), which I recommend), but doing simple I/O is actually not complicated.

main = do {
text <- readFile "somefile.txt";
print $ length $ lines text;

This is the Haskell code to read a text file, split it in to lines, count the number of lines, and print out that number. Pretty simple!

What about mutation? Well, it is true that there are no globals in Haskell, but really, who uses globals? If you really need mutation for something, the simplest way to make a reference is:

import Data.IORef

main = do {
someRef <- newIORef 1;
val <- readIORef someRef;
print val;
writeIORef someRef 12;
val <- readIORef someRef;
print val;

Of course, if you want you could make this a bit less verbose:

import Data.IORef

x := y = writeIORef x y
new x = newIORef x
get x = readIORef x

main = do {
someRef <- new 1;
val <- get someRef;
print val;
someRef := 12;
val <- get someRef;
print val;

Many Libraries

Haskell has a very active community that has produced many libraries covering all sorts of cases. The main place to look for these is Hackage.


Another thing that drew me to Ruby initially was irb. The ability to just fire up a shell-like environment and enter expressions, and load in my code and play with it live, is a very nice thing. There are several such environments for Haskell, the one that I prefer is GHCI, which also has commands to set breakpoints and such (which I have never needed) and to find out what the type of some expression is (very handy).

Other Useful Bits

There is a very useful tool for Haskell called hlint, which analyses your code and make (sometimes surprisingly insightful) suggestions. I don’t always agree with it, but it is very nice.

Debug.Trace is a very useful library for printing out arbitrary values from anywhere in your code without otherwise affecting the behaviour of the code. Very useful for debugging.

If you want to learn more, I highly recommend Learn You a Haskell for Great Good.