the happy developer environment strikes back

Fresh from the developer wiki, I bring you the last installment of my preferred development sandbox setup, for you to try and enjoy:

 

(Optional/Mac-OSX)

Install boot2docker

Docker runs in a VirtualBox VM through an image called boot2docker. The reason we have to use boot2docker and VirtualBox is because the Mac OSX filesystem is not compatible with the type of filesystem required to support Docker. Hence, we must run our Docker containers within yet another virtual machine.
Download and install VirtualBox.
Now install boot2docker and Docker Compose.

   $ brew install boot2docker docker-compose

Initialize and start up boot2docker

   $ boot2docker init
   $ boot2docker start

Configure your Docker host to point to your boot2docker image.

   $ $(boot2docker shellinit)

You’ll need to run this for every terminal session that invokes the docker or docker-compose command – better export this line into your .zshrc or .bashrc.

 

Install docker from the web

Install docker

 

Install docker-compose from docker web

Install docker-compose

 

Create Dockerfile

Create on project root with following content

 # ./Dockerfile
 FROM ruby:2.2
 MAINTAINER name@wearepeople.io
 
 ENV APP_PATH /app
 
 # This will be a host folder mounted to cache installed gems
 ENV BUNDLE_PATH /bundle
 
 # Install apt based dependencies required to run Rails as
 # well as RubyGems. As the Ruby image itself is based on a
 # Debian image, we use apt-get to install those.
 RUN apt-get update -qq && apt-get install -y build-essential libpq-dev
 
 RUN mkdir -p $APP_PATH
 
 # Expose port 3000 to the Docker host, so we can access it
 # from the outside.
 EXPOSE 3000
 
 # Configure the main working directory. This is the base
 # directory used in any further RUN, COPY, and ENTRYPOINT
 # commands. 
 WORKDIR $APP_PATH
 
 # Copy the main application.  
 COPY . $APP_PATH
 
 # The main command to run when the container starts. Also
 CMD ./start

 

Create .dockerignore

Create .dockerignore file with following contents:

 .git*
 log/*
 tmp/*
 Dockerfile
 README.rdoc

 

Create de comopse config

Create docker-compose.yml file with following contents:

 # docker-compose.yml
 app:
   build: .
   command: "./start"
   volumes:
     - .:/app
     - .bundle:/bundle  # gem cache folder
   ports:
     - "3000:3000"
   links:
     - db
     - mail
     - redis
   environment:
     BUNDLE_JOBS: 4
 db:
   image: postgres
   ports:
     - "5432"
 redis:
   image; redis
   ports:
     - "6379"
 mail:
   image: schickling/mailcatcher
   ports:
     - "1080:1080"

 

Adapt application configurations accordingly:

• config/database.yml

 development: &default
   adapter: postgresql
   encoding: unicode
   database: appname_development
   pool: 5
   username: postgres
   password:
   host: db
 
 test:
   <<: *default
   database: appname_test

• ./start

 #!/usr/bin/env bash
 
 echo "Removing old server pid's if any..."
 rm -f tmp/pids/server.pid
 
 echo "Checking bundle dependencies..."
 bundle check || bundle install
 
 echo "Booting up..."
 bundle exec rails s -p 3000 -b 0.0.0

• config/initializers/session_store.rb

 redis_server = ENV['REDIS_PORT_6379_TCP_ADDR'] || 'localhost' # docker sets ENV, production uses localhost for now
 redis_port   = ENV['REDIS_PORT_6379_TCP_PORT'] || '6379'
 
 Coaching::Application.config.session_store :redis_store,
   servers: "https://#{redis_server}:#{redis_port}/session"

 

Build containers

 docker-compose build

 

Initialize Gems & Database

 docker-compose run app bash -c 'bundle install && rake db:setup'
 

 

Run app

This will start app container (and dependencies) as a daemon, thus leaving the terminal free

 docker-compose up -d

And this allows us to follow the process output/log as 'tail -f' or 'foreman start' would do

 docker-compose logs

There are other useful commands listed here: docker-compose commandline reference

Developer experience, and "you don't have to be big too be cool"

Today I want to talk about something written by @david_bonilla author of a well known weekly mail-list where he publicly meditates on the Spanish software industry, the start-up ecosystem and whatnot.

In his last issue he speaks about how some companies alienate visitors, even business relevant and required visitors in lieu of a poor understanding of security or negotiation or both.

But what first caught my attention was the example he set.

«To a computer techie, your laptop is like the katana for a Samurai. It is not a simple tool of the trade, but an item of such complicity and familiarity, that it is perceived as an extension of one's self. Therefore, when a security guard stamps some sticker on it , it bothers me as much as if was being stick to my forehead or you were to tuck a finger in my nose and revolve counter-clockwise.»

image by solvash

This, besides of showing David's humorous narrative skill's addresses something that has been silently bothering me since I started to thrive as a developer until recently.

At every company I worked for before, I have been provided with a set of tools mostly to the company (usually naive) understanding of my needs. Some were outright crappy, like a 14'' CRT 10 year old clone with no internet.

Some others were a mark or hierarchy/privilege, so when someone new entered the company, new equipment was bought and assigned to the bossiest person, who would pass remains along to ne next and so on, so the new person had the scrapings nobody else wanted.

My last employer did a very good effort to provide powerful and competitive equipment, but they struggled with customizabillity (like fixed provider, fixed OS, fixed -old- OS version...)

At my current company, the smallest I have worked for so far, has been the first to say: «this is your tool, so we pay for it but you must choose what it is to be like». I know it to be a great deal for a company of this size to do this. I came up with a very effective setup free of any extravaganzas. And also was offered to choose chair, laptop stand, screen...

I took me the best of nine years to find someone in Spain understanding what Joel Spolsky was saying back in 2006, and it was not some cool SF start-up, it was a coder-born entrepreneur.

This is an open advise to all that companies throwing sacks of euros/dollars to recruiters, and languishing to find good talent. If you want good and great developers to come to you, and stay with you, stop patronizing, just treat them well, like professionals that know what they are doing, and let everybody know how you roll.