_____101 |> F# Coding Ecosystem: Paket && Atom w/ Paket

One extremely useful tool to use with F# is Paket. Paket is a package manager that provides a super clean way to manage your dependencies. Paket can handle everything from Nuget dependencies to git or file dependencies. It really opens up your project capabilities to easily pull in and handle dependencies, whereever they are located.

I cloned the Paket Project first, since I would like to have the very latest and help out if anything came up. For more information on Paket check out the about page.

git clone git@github.com:fsprojects/Paket.git

I built that project with the respective ./build.sh script and all went well.


NOTE – Get That Command Line Action

One thing I didn’t notice immediately in the docs (I’m putting in a PR right after this blog entry) was anyway to actually get Paket setup for the command line. On bash, Windows, or whatever, it seemed a pretty fundamental missing piece so I’m going to doc that right here but also submit a PR based on the issue I added here). It could be I just missed it, but either way, here’s the next step that will get you setup the rest of the way.


Yeah, that’s all it was. Kind of silly eh? Maybe that’s why it isn’t documented that I could see? After the installation script is run, just execute paket and you’ll get the list of the various commands, as shown below.

$ paket
Paket version
Command was:
available commands:

	add: Adds a new package to your paket.dependencies file.
	config: Allows to store global configuration values like NuGet credentials.
	convert-from-nuget: Converts from using NuGet to Paket.
	find-refs: Finds all project files that have the given NuGet packages installed.
	init: Creates an empty paket.dependencies file in the working directory.
	auto-restore: Enables or disables automatic Package Restore in Visual Studio during the build process.
	install: Download the dependencies specified by the paket.dependencies or paket.lock file into the `packages/` directory and update projects.
	outdated: Lists all dependencies that have newer versions available.
	remove: Removes a package from your paket.dependencies file and all paket.references files.
	restore: Download the dependencies specified by the paket.lock file into the `packages/` directory.
	simplify: Simplifies your paket.dependencies file by removing transitive dependencies.
	update: Update one or all dependencies to their latest version and update projects.
	find-packages: EXPERIMENTAL: Allows to search for packages.
	find-package-versions: EXPERIMENTAL: Allows to search for package versions.
	show-installed-packages: EXPERIMENTAL: Shows all installed top-level packages.
	pack: Packs all paket.template files within this repository
	push: Pushes all `.nupkg` files from the given directory.

	--help [-h|/h|/help|/?]: display this list of options.

Paket Elsewhere && Atom

If you’re interested in Paket with Visual Studio I’ll let you dig into that on your own. Some resources are Paket Visual Studio on Github and Paket for Visual Studio. What I was curious though was Paket integration with either Atom or Visual Studio Code.

Krzysztof Cieślak (@k_cieslak) and Stephen Forkmann (@sforkmann) maintain the Paket.Atom Project and Krzysztof Cieślak also handles the atom-fsharp project for Atom. Watch this gif for some of the awesome goodies that Atom gets with the Paket.Atom Plugin.

Click for fullsize image of the gif.

Click for fullsize image of the gif.

Getting Started and Adding Dependencies

I’m hacking along and want to add some libraries, how do I do that with Paket? Let’s take a look. This is actually super easy, and doesn’t make the project dependentant on peripheral tooling like Visual Studio when using Paket.

The first thing to do, is inside the directory or project where I need the dependency I’ll intialize the it for paket.

paket init

The next step is to add the dependency or dependencies that I’ll need. I’ll add a Nuget package that I’ll need shortly. The first package I want to grab for this project is FsUnit, a testing framework project managed and maintained by Dan Mohl @dmohl and Sergey Tihon @sergey_tihon.

paket add nuget FsUnit

When executing this dependency addition the results displayed show what other dependencies were installed and which versions were pegged for this particular dependency.

✔ ~/Codez/sharpPaketsExample
15:33 $ paket add nuget FsUnit
Paket version
Adding FsUnit to /Users/halla/Codez/sharpPaketsExample/paket.dependencies
Resolving packages:
 - FsUnit 1.3.1
 - NUnit 2.6.4
Locked version resolution written to /Users/halla/Codez/sharpPaketsExample/paket.lock
Dependencies files saved to /Users/halla/Codez/sharpPaketsExample/paket.dependencies
Downloading FsUnit 1.3.1 to /Users/halla/.local/share/NuGet/Cache/FsUnit.1.3.1.nupkg
NUnit 2.6.4 unzipped to /Users/halla/Codez/sharpPaketsExample/packages/NUnit
FsUnit 1.3.1 unzipped to /Users/halla/Codez/sharpPaketsExample/packages/FsUnit
3 seconds - ready.

I took a look in the packet.dependencies and packet.lock file to see what were added for me with the paket add nuget command. The packet.dependencies file looked like this now.

source https://nuget.org/api/v2

nuget FsUnit

The packet.lock file looked like this.

  remote: https://nuget.org/api/v2
    FsUnit (1.3.1)
      NUnit (2.6.4)
    NUnit (2.6.4)

There are a few more dependencies that I want, so I went to work adding those. First of this batch that I added was FAKE (more on this in a subsequent blog entry), which is a build tool based off of RAKE.

paket add nuget FAKE

Next up was FsCheck.

paket add nuget FsCheck

The paket.dependencies file now had the following content.

source https://nuget.org/api/v2

nuget FAKE
nuget FsCheck
nuget FsUnit

The paket.lock file had the following items added.

  remote: https://nuget.org/api/v2
    FAKE (4.1.4)
    FsCheck (2.0.7)
      FSharp.Core (>=
    FSharp.Core (
    FsUnit (1.3.1)
      NUnit (2.6.4)
    NUnit (2.6.4)

Well, that got me started. The code repository at this state is located on this branch here of the sharpSystemExamples repository. So on to some coding and the next topic. Keep reading, subsribe, or hit me up on twitter @adron.


______10 |> F# – Moar Thinking Functionally (Notes)

More notes on the “Thinking Functionally” series. Previous notes are @ “_______1 |> F# – Getting Started, Thinking Functionally“.

#6 Partial Application

Breaking down functions into single parameter functions is the mathematically correct way of doing it, but that is not the only reason it is done — it also leads to a very powerful technique called partial function application.

For example:

let add42 = (+) 42 // partial application
add42 1
add42 3

[1;2;3] |> List.map add42

let twoIsLessThan = (<) 2 // partial application twoIsLessThan 1 twoIsLessThan 3 // filter each element with the twoIsLessThan function [1;2;3] |> List.filter twoIsLessThan

let printer = printfn "printing param=%i"

[1;2;3] |> List.iter printer

Each case a partially applied function above it can then be reused in multiple contexts. It can also fix function parameters.

let add1 = (+) 1
let add1ToEach = List.map add1   // fix the "add1" function

add1ToEach [1;2;3;4]

let filterEvens =
   List.filter (fun i -> i%2 = 0) // fix the filter function

filterEvens [1;2;3;4]

Then the following shows plug in behavior that is transparent.

let adderWithPluggableLogger logger x y =
    logger "x" x
    logger "y" y
    let result = x + y
    logger "x+y"  result

let consoleLogger argName argValue =
    printfn "%s=%A" argName argValue 

let addWithConsoleLogger = adderWithPluggableLogger consoleLogger
addWithConsoleLogger  1 2
addWithConsoleLogger  42 99

let popupLogger argName argValue =
    let message = sprintf "%s=%A" argName argValue
      |> ignore

let addWithPopupLogger  = adderWithPluggableLogger popupLogger
addWithPopupLogger  1 2
addWithPopupLogger  42 99

Designing Functions for Partial Application

Sample calls to the list library:

List.map    (fun i -> i+1) [0;1;2;3]
List.filter (fun i -> i>1) [0;1;2;3]
List.sortBy (fun i -> -i ) [0;1;2;3]

Here are the same examples using partial application:

let eachAdd1 = List.map (fun i -> i+1)
eachAdd1 [0;1;2;3]

let excludeOneOrLess = List.filter (fun i -> i>1)
excludeOneOrLess [0;1;2;3]

let sortDesc = List.sortBy (fun i -> -i)
sortDesc [0;1;2;3]

Commonly accepted guidelines to multi-parameter function design.

  1. Put earlier: parameters ore likely to be static. The parameters that are most likely to be “fixed” with partial application should be first.
  2. Put last: the data structure or collection (or most varying argument). Makes it easier to pipe a structure or collection from function to function. Like:
    let result =
       |> List.map (fun i -> i+1)
       |> List.filter (fun i -> i>5)
  3. For well-known operations such as “subtract”, put in the expected order.

Wrapping BCL Function for Partial Application

Since the data parameter is generally last versus most BCL calls that have the data parameter first, it’s good to wrap the BCL.

let replace oldStr newStr (s:string) =
  s.Replace(oldValue=oldStr, newValue=newStr)

let startsWith lookFor (s:string) =

Then pipes can be used with the BCL call in the expected way.

let result =
     |> replace "h" "j"
     |> startsWith "j"

["the"; "quick"; "brown"; "fox"]
     |> List.filter (startsWith "f")

…or we can use function composition.

let compositeOp = replace "h" "j" >> startsWith "j"
let result = compositeOp "hello"

Understanding the Pipe Function

The pipe function is defined as:

let (|>) x f = f x

It allows us to put the function argument in front of the function instead of after.

let doSomething x y z = x+y+z
doSomething 1 2 3

If the function has multiple parameters, then it appears that the input is the final parameter. Actually what is happening is that the function is partially applied, returning a function that has a single parameter: the input.

let doSomething x y  =
   let intermediateFn z = x+y+z
   intermediateFn        // return intermediateFn

let doSomethingPartial = doSomething 1 2
doSomethingPartial 3
3 |> doSomethingPartial

#7 Function Associativity and Composition

Function Associativity


let F x y z = x y z

…means this…

let F x y z = (x y) z

Also three equivalent forms.

let F x y z = x (y z)
let F x y z = y z |> x
let F x y z = x <| y z

Function Composition

Here’s an example

let f (x:int) = float x * 3.0  // f is int->float
let g (x:float) = x > 4.0      // g is float->bool

We can create a new function h that takes the output of “f” and uses it as the input for “g”.

let h (x:int) =
    let y = f(x)
    g(y)                   // return output of g

A much more compact way is this:

let h (x:int) = g ( f(x) ) // h is int->bool

h 1
h 2

These are notes, to read more check out the Function Composition.

_______1 |> F# – Getting Started, Thinking Functionally (Notes)

Recently I took the plunge into writing F# on OS-X and Linux (Ubuntu specifically). This is the first of a new series I’m starting (along with my other ongoing series on JavaScript workflow and practices). In this article particularly I’m just going to provide an overview and notes of key paradigms in functional programming. Most of these notes are derived from a great series called “Thinking Functionally“.

#1 Thinking Functionally: Introduction

This is the article that kicks off the series. The emphasis is focused around realizing that a different way of thinking needs applied when using a functional language. The difference between functional thinking and imperative. The key topics of the series includes:

  • Mathematical Functions
  • Functions and Values
  • Types
  • Functions with Multiple Parameters
  • Defining Functions
  • Function Signatures
  • Organizing Functions

#2 Mathematical Functions

Functional programming, its paradigms and its origins, are all rooted in mathematics. A mathematical function looks something like this:

Add1(x) = x + 1

  • The set of values that can be used as input to the function is called the domain.
  • The set of possible output values from the function is called the range.
  • The function is said to map the domain to the range.

If F# the definition would look like this.

let add1 x = x + 1

The signature of the function would look like this.

val add1 : int -> int

Key Properties of Mathematical Functions

  • A function always gives the same output value for a given input value.
  • A function has no side effects.

Pure functions

  • They are trivially parallelizable.
  • I can use a function lazily.
  • A function only needs to be evaluated once. (i.e. memoization)
  • The function can be evaluated in any order.

Prospectively “Unhelpful” properties of mathematical functions

  • The input and output values are immutable.
  • A function always has exactly one input and one output

#3 Function Values and Simple Values

Looking at this function again:

let add1 x = x + 1

The x means:

  • Accept some value from the input domain.
  • Use the name “x” to represent that value so that we can refer to it later.

It is also referred to as x is bound to the input value. In this binding it will only ever be that input value. This is not an assignment of a variable. Emphasis on the fact that there are no “variables”, only values. This is a critical part of functional thinking.

Function Values: this is a value that provides binding for a function to a name.

Simple Values: This is what one might think of as constants.

let c = 5

Simple Values vs. Function Values

Both are bound to names using the keyword let. The key difference is a function needs to be application to an argument to get a result, and a simple value doesn’t, as it is the value it is.

“Values” vs. “Objects”

In F# most things are referred to as “values”, contrary to “objects” in C# (or other languages like JavaScript for that matter). A value is just a member of a domain, such as a domain of ints, string, or functions that map ints to strings. In theory a value is immutable and has no behavior attached to it. However in F#, even some primitive values have some object-like behavior such as calling a member or property with dot notation syntax like “theValue”.Length or something similar.

Naming Values

Most of the naming is the general ruleset that applies to practically every language. However there is one odd feature that comes in handy in some scenarios. Let’s say you want to have a name such as “this is my really long and flippantly ridiculous name” for a domain. Well, what you can use is the “this is my really long and flippantly ridiculous name“ to have that be the name. It’s a strange feature, but I’ll cover more of it in subsequent articles.

In F# it is also practice to name functions and values with camel case instead of pascal case (camelCase vs. PascalCase).

#4 How Types Work with Functions

Function signatures look like this, with the arrow notation.

val functionName : domain -> range

Example functions:

let intToString x = sprintf "x is %i" x  // format int to string
let stringToInt x = System.Int32.Parse(x)

Example function signatures:

val intToString : int -> string
val stringToInt : string -> int

This means:

  • intToString has a domain of int which it maps onto the range string.
  • stringToInt has a domain of string which it maps onto the range int.

Primitive Types

Standard known types you’d expect: string, int, float, bool, char, byte, etc.

Type Annotations

Sometimes type might not be inferred, if that is the case, the compiler can take annotations to resolve type.

let stringLength (x:string) = x.Length   
let stringLengthAsInt (x:string) :int = x.Length 

Function Types as Parameters

A function that takes other functions as parameters, or returns a function, is called a higher-order function (sometimes abbreviated as HOF).


let evalWith5ThenAdd2 fn = fn 5 + 2 

The signature looks like:

val evalWith5ThenAdd2 : (int -> int) -> int

Looking at an example executing. The example:

let times3 x = x * 3
evalWith5ThenAdd2 times3

The signature looks like:

val times3 : int -> int
val it : int = 17

Also these are very sensitive to types, so beward.

let times3float x = x * 3.0
evalWith5ThenAdd2 times3float

Gives an error:

error FS0001: Type mismatch. Expecting a int -> int but 
              given a float -> float

Function as Output

A function value can also be the output of a function. For example, the following function will generate an “adder” function that adds using the input value.

let adderGenerator numberToAdd = (+) numberToAdd

Using Type Annotations to Constrain Function Types

This example:

let evalWith5ThenAdd2 fn = fn 5 +2

Becomes this:

let evalWith5AsInt (fn:int->int) = fn 5

…or maybe this:

let evalWith5AsFloat (fn:int->float) = fn 5

The “unit” Type

When a function returns no output, it still requires a range, and since there isn’t a void function in mathematical functions this supplants the void as return output. This special range is called a “unit” and has one specific value only, a “()”. It is similar to a void type or a null in C# but also is not, in that it is the value “()”.

Parameterless Functions

For a WAT moment here, parameterless functions come up. In this example we might expect “unit” and “unit”.

let printHello = printf "hello world" 

But what we actually get is:

hello world
val printHello : unit = ()

Like I said, a very WAT kind of moment. To get what we expect, we need to force the definition to have a “unit” argument, as shown.

let printHelloFn () = printf "hello world"

Then we get what we expect.

val printHelloFn : unit -> unit

So why is this? Well, you’ll have to dive in a little deeper and check out the F# for fun and profitThinking Functional” entry on “How Types Work with Functions” for the full low down on that. Suffice it I’ve documented how you get what you would expect, the writer on the site goes into the nitty gritty of what is actually happening here. Possibly, you might have guessed what is happen already. There is also some strange behavior that takes place with forcing unit types with the ignore function that you may want to read on that article too, but if you’re itching to move on, and get going faster than digging through all of this errata, keep going. I’m going to jump ahead to the last section I want to cover for this blog entry of notes, currying.

#5 Currying

Haskell Curry

Haskell Curry

Breaking multi-parameter functions into smaller one-parameter functions. The way to write a function with more than one parameter is to use a process called currying. For more history on this check out Haskell Curry the mathematician to dive deep into his work (which also covers a LOT of other things beside merely currying, like combinatory logic and Curry’s paradox for instance).

Basic example:

let printTwoParameters x y = 
   printfn "x=%i y=%i" x y

This of course looks neat enough right? Well, if we look at the compiler rewrite, it gets rather interesting.

let printTwoParameters x =
   let subFunction y = 
      printfn "x=%i y=%i" x y

OS-X and F# [Clone It, Build It, Install It, Hack It]


Mission: Get F# running on OS-X and executing via repl.

There are a number of steps here, that if you don’t have everything covered things just won’t work. So let’s knock out the prerequisites first. This will include getting autoconf installed. There are some other tools that I’ve added below that are good to have installed too, so get autoconf, automake, and libtool installed.

export build=~/devtools # or wherever you'd like to build
mkdir -p $build
cd $build
curl -OL http://ftpmirror.gnu.org/autoconf/autoconf-2.68.tar.gz
tar xzf autoconf-2.68.tar.gz
cd autoconf-2.68
./configure --prefix=/usr/local
sudo make install
export PATH=/usr/local/bin
cd $build
curl -OL http://ftpmirror.gnu.org/automake/automake-1.11.tar.gz
tar xzf automake-1.11.tar.gz
cd automake-1.11
./configure --prefix=/usr/local
sudo make install
cd $build
curl -OL http://ftpmirror.gnu.org/libtool/libtool-2.4.tar.gz
tar xzf libtool-2.4.tar.gz
cd libtool-2.4
./configure --prefix=/usr/local
sudo make install

Now we’re ready to get some F# (64-bit flavors too) running on OS-X. This is very likely to take more than a few minutes because we’ve got two actual builds to do here.

First step is to get mono built and installed.

git clone https://github.com/mono/mono
cd mono
./autogen.sh --prefix=/mono64 --enable-nls=no
sudo make install

Now clone fsharp, build and install it.

git clone https://github.com/fsharp/fsharp
cd fsharp
./autogen.sh --prefix=/mono64
sudo make install

Finally get the binary executable paths added to the paths file.

vi /etc/paths

Add the following paths to the paths file.


Once that’s done, run the tests to confirm everything has built right and is operable.

cd tests/fsharp/core

Now… that should all be ok.


What I wanted now is something to sling some code and execute it. The easiest way, is to use the ‘fsharpi’ repl. At the OS-X terminal launch the repl.
Enter this line…

let x = 5;;

Then let y to a value…

let y = 20;;

Then enter…

y + x;;

…and you should see the math calculated. Then you can quit out of the repl with the following command.


The overall repl should come out looking like this.

> let x = 5;;

val x : int = 5

> let y = 20;;

val y : int = 20

> y + x;;
val it : int = 25
> #quit;;

- Exit...

Compilation – A Step Further

Just to show one more step. Let’s do a compile of a file with F# Code in it. Create a file called process.fs and enter the following code.

open System

let main (argv :string[]) = 
    printfn "Hello World" 
    Console.ReadLine() |> ignore

Now run the compiler ‘fsharpc’.

fsharpc process.fs

Now before you freak out screaming “OMG WTF am I supposed to do with a process.exe file…!!!” just calm down and execute the following command.

mono process.exe

There you’ll see the execution of “Hello World”. Welcome to F# on OS-X. More to come, Keep thrashing code!

Note: I’ve got a github repo for this and coming F# coding available at sharpgrounds.

My Year of Coding, Messaging, Learning, Leading, Reconoitering, and Hacking in Photos

Hope you have a little patience, this blog entry is going to be pretty long. There was a multitude of conferences, more than a hundred pair coding sessions, more cities, hotels and other things as I criss crossed the country helping to knock out projects, code, fire off some open source projects and generally get some technology implemented. It has been a spectacular year. I also could add, it has thoroughly kicked my ass and I’ve loved it.

2012 Coding Projects

In 2012 I’ve taken the healm of the Iron Foundry Project which led to the creation of Tier 3 Web Fabric PaaS. A Cloud Foundry & Iron Foundry .NET based PaaS. From there the project led to an expansion of leading the efforts on the Thor Project, which is a Cloud Foundry User Interface for OS-X and Windows 7. Beyond that I’ve contributed to and participated in dozens of different projects in various ways over the year. I finished up this year by joining Basho in December and thus, joined the Riak & related Basho Projects.

Coding Project Aims For 2013

Some of the projects I’ve started, will join or hope to otherwise continue participation in include the following. Here’s to hoping 2013 is a hard core coding and contributing year of excellence!

  • Many of the Basho Organization’s Projects I’ll be diving into, including work around Rebar, Riak, Docs & a number of others.
  • Name Factory – a project I’ve started a while back of Riak + JavaScript around creating massive test data with JavaScript and also using Riak for the storage & searching on that data created.
  • Criollo – Criollo is one of the most common forms of cocoa, is a native OS-X Cocoa User Interface for distributed systems built on or using Riak.
  • SpikeOp – This I’ve dubbed the name of the iOS interface for distributed systems built on or using Riak.
  • I want to use and possibly contribute to Corrugated Iron, the .NET Client for Riak. Prospectively to use for a Windows 8 User Interface for distributed systems built on or using Riak.
  • I’ll continue to maintain and provide support for the Iron Foundry vcap-client Library currently available via Nuget for .NET.
  • Thor Project for Cocoa & Thor .NET for Cloud Foundry & Iron Foundry.
  • Expand on prospective services for Cloud Foundry, either I or efforts I may lead to do this.

…there are others, but they’ll have to be figured out during the course of events. Also, there are an easy dozen other projects I’ll be working that don’t particularly have to do with coding, two are listed below. For an easy way to keep up with the projects I’m coding on, leading, participating in or otherwise hit me up on Twitter @adron or ADN @adron.

Big Project Aims for 2013

Thrashing Code Project – This is sort of, kind of secret. It’s going to happen soon, I have a personal schedule for it and I’ll be releasing information accordingly when the site and twitter account goes live.

Tour Triumvirate – I intend to plan, and hopefully will take at least 2 of the three tech tours I setup. More information will be forthcoming, but the original notion is outlined in the blog entry I wrote titled “The Adron Code Tour, Let’s Hack, Bike and Talk Hard Core Technology“.

Books I’ve Read in 2012

All of these I’ve either read or re-read in 2012. I set a goal at the beginning of last year to get my ass in gear when it comes to reading. A focused, get it read, understood and learn approach. I think I did pretty good overall. Not a book a week, but I’m getting back in gear. Considering my best year of reading was 100+ books, it might be a difficult to reach that again since I’m a working citizen, versus a child with plenty of time on their hands. But, it’s good to have goals.  😉

  • The Clean Coder: A Code of Conduct for Professional Programmers
  • The Rails 3 Way
  • Eloquent Ruby
  • The Economics of Freedom: What Your Professors Won’t Tell You, Selected Works of Frederic Bastiat
  • The Myth of the Robber Barons
  • Excellence Without a Soul: Does Liberal Education Have a Future?
  • Seven Databases in Seven Weeks: A Guide to Modern Databases and the NoSQL Movement
  • Surely You’re Joking, Mr. Feynman!
  • The Innovator’s Dilemma: The Revolutionary Book That Will Change the Way You Do Business
  • The Lean Startup: How Today’s Entrepreneurs Use Continuous Innovation to Create Radically Successful Businesses
  • 8 Things We Hate About IT: How to Move Beyond the Frustrations to Form a New Partnership with IT
  • Smart and Gets Things Done: Joel Spolsky’s Concise Guide to Finding the Best Technical Talent
  • Rework
  • Steve Jobs
  • Eloquent JavaScript: A Modern Introduction to Programming
  • JavaScript: The Good Parts
  • Node for Front-End Developers
  • First Contact (In Her Name: The Last War, #1)
  • Cloudonomics: The Business Value of Cloud Computing
  • The REST API Design Handbook
  • HTML5 Canvas
  • HTML5: Up and Running
  • Triumph of the City: How Our Greatest Invention Makes Us Richer, Smarter, Greener, Healthier, and Happier
  • Traffic

Book Reading Aims for 2013

  • Natural Capitalism
  • How God Changes Your Brain: Breakthrough Findings from a Leading Neuroscientist
  • Discourse on the Method of Rightly Conducting One’s Reason and of Seeking Truth in the Sciences
  • Political Ideals
  • The Autobiography of Benjamin Franklin
  • Wrestling with Moses: How Jane Jacobs Took On New York’s Master Builder and Transformed the American City
  • Bikenomics: An Introduction to the Bicycle Economy
  • Everyday Bicycling: How to Ride a Bike for Transportation (Whatever Your Lifestyle)
  • Just Ride: A Radically Practical Guide to Riding Your Bike
  • Continuous Delivery: Reliable Software Releases through Build, Test, and Deployment Automation
  • Erlang Programming
  • Building Web Applications with Erlang: Working with REST and Web Sockets on Yaws
  • Think Complexity: Complexity Science and Computational Modeling
  • Async JavaScript
  • Smashing Node.js: JavaScript Everywhere (Smashing Magazine Book Series)
  • Windows PowerShell for Developers
  • How to Use the Unix-Linux vi Text Editor
  • Sketching User Experiences: The Workbook
  • Designing Interfaces
  • Information Architecture for the World Wide Web: Designing Large-Scale Web Sites
  • Consider Phlebas
  • Snow Crash
  • How to Change the World: Social Entrepreneurs and the Power of New Ideas
  • Mission, Inc.: The Practitioner’s Guide to Social Enterprise
  • Simply Complexity
  • Complex Adaptive Systems: An Introduction to Computational Models of Social Life (Princeton Studies in Complexity)
  • Thinking In Systems: A Primer
  • Thinking, Fast and Slow
  • Programming in Objective-C
  • Learning iPad Programming: A Hands-on Guide to Building iPad Apps with iOS 5
  • Cocoa Programming for Mac OS X
  • Getting Started with GEO, CouchDB, and Node.js
  • JavaScript Web Applications
  • Suburban Nation: The Rise of Sprawl and the Decline of the American Dream
  • Design Patterns in Ruby

…and the two books I’d like to re-read this year because they’re just absurdly entertaining and I’d like a refresher of the stories.

  • A Confederacy of Dunces (I’ll be reading this for the 2nd time)
  • The Hitchhiker’s Guide to the Galaxy (Yup, just want to read it again)

My 2012 Coder’s Year in Photos

What I’ve put together here is a photo story of the year, hopefully it’s entertaining in some way. With that, here’s a review of the year, cheers and happy new year! 2012 started with one of my last hack sessions as a Seattle Resident at Ruby at Racer weekly meetup.

Ruby at Racer Meetup

Ruby at Racer Meetup

Meanwhile some of my last views from Russell Investments. Absolutely beautiful, epic and awe inspiring views of the Puget Sound from the Emerald City of Seattle.

View from Russell Investments Seattle Headquarters, stunning!

View from Russell Investments Seattle Headquarters, stunning!

Then a fitting image, from the business meeting floor of the same building, the settings sun for my departure.

Overlooking the Puget Sound, Japanese Garden in the forefront from the Russell Investments Building in Seattle.

Overlooking the Puget Sound, Japanese Garden in the forefront from the Russell Investments Building in Seattle.

February of 2012 kicked of with my return to Portland, Oregon. Stumptown regularly welcomed me back more than a few moments.

Stumptown Morning Brew

Stumptown Morning Brew

One of the first meetups I attended back in Portland was the DevOps Meetup.

DevOps DevOpers Hanging around pre-meeting at PuppetLabs in Portland.

DevOps DevOpers Hanging around pre-meeting at PuppetLabs in Portland.

That DevOps meetup just happened to have a session on one of the code bases I was working with, Cloud Foundry.

Cloud Foundry preso on how the pull requests and such where going to be built into a process, which still today is rather cumbersome for community involvement. However, it's still moving forward, albeit at a slower pace than it could if it was streamlined around github instead of github being an

Cloud Foundry preso on how the pull requests and such where going to be built into a process, which still today is rather cumbersome for community involvement. However, it’s still moving forward, albeit at a slower pace than it could if it was streamlined around github instead of github being an “end point” read only repository…

While my move consisted of many a couch, as I just couch surfed for the first 45 or so days I was back in Portland, I finally moved into a place at the Indigo in downtown.

My New Place, priorities as they are my system sits in the corner ready for use.

My New Place, priorities as they are my system sits in the corner ready for use.

The new system, albeit a great Christmas present from 2011, became the defacto work system of 2012 and remains one of my top machines. Mac Book Air w/ 4GB RAM, i5 Proc, 256 GB SSD. Not a bad machine.

2011 Mac Book Air, settled into it's workspace cradle.

2011 Mac Book Air, settled into it’s workspace cradle.

A view from on high, looking down upon the streets of San Francisco from the New Relic Offices. Thanks for the invite and the visit, it was great meeting the great team at New Relic San Francisco!

New Relic San Francisco View

New Relic San Francisco View

Getting around on my first trip to San Francisco of 2012. Thanks to John, Bjorn, Bill, John and the whole team in Portland and San Francisco for the invite. Great talking to you guys.

MUNI Streetcar FTW!

MUNI Streetcar FTW!

On the same trip it began pouring rain as I’d never seen before in San Francisco. I sat by Duboche Park, staying warm and away from drowning! Arriving outside was one of the MUNIs that eventually I was rescued by from the torrential floods and returned to downtown, dry and intact!

MUNI to the rescue on the torrential downpour of the year in San Francisco.

MUNI to the rescue on the torrential downpour of the year in San Francisco.

…and Julia thanks for the tour around San Francisco and the extra tasty lunch at EAT!! Good times!

Eating at the EAT sign!

Eating at the EAT sign!

Amidst all these images, I threw together some into a collage. There are a number of awesome coders & hackers of all sorts in these images. Shout out to Jerry Sievert, Eric Sterling,

Snikies, a collage I made!!!! (This one you can click on for a full size image)

Snikies, a collage I made!!!! (This one you can click on for a full size image)

…and alas I’ll have another zillion images and such as we all roll into 2013 and onward. Cheers! For some more new years posts I’ve found useful check out this list, which I’ll be adding to over the next few days.