Artur Roszczyk

Subscription tracking in Sendgrid and Rails 4

2013-08-03T00:00:00-07:00

Subscription tracking in Sendgrid and Rails 4

Few days ago I extracted mailer classes out of our monolith app. I created a new, small Rails 4 application which consumes RabbitMQ queue and sends emails to users. We use Sendgrid’s subscription tracking. We use particularly a placeholder, which Sendgrid replaces by unsubscription url.

  # in mailer

  sendgrid_subscriptiontrack_text(:replace => '[unsubscribe]')

  # in template

  <a href="\[unsubscribe\]">click here.</a>

The problem was, that the placeholder [unsubscribe] was replaced by a bogus URL like x-msg://447/\[unsubscribe\]. It turns out, that Rails 4 encodes automatically all URLs in emails.

The fix

Sendgrid does not decode these URLs, so I needed to encode the placeholder.

  # in mailer

  sendgrid_subscriptiontrack_text(:replace => '%5Bunsubscribe%5D')

I hope that this will save you some time.

New Year's resolutions

2013-01-01T00:00:00-08:00

New Year’s resolutions

It’s common to say, that resolutions made at beggining of year just don’t work. Although I would like to set directions of improving myself for coming year. I hope to revisit them by end of 2013 ;-).

pay off debts
establish security savings
have true vacation
write more
spend more time with family
shift from 8am-1am day to 6am-22pm day
quit tv-series addiction
start doing some sport

Basics of fog and AWS for Rails apps

2012-12-31T00:00:00-08:00

Basics of fog and AWS for Rails apps

All successful projects grow. In the beginning we usually don’t care about scalability so much. The need of it comes often suddenly. You cannot predict effects of being advertised on popular blog or going viral. Then you need to scale up to serve the traffic.

There are many options to fix this. You can start with Heroku, but you might need more flexibility later and move to bare servers on Hetzner. And Hetzner might be a fit for you for several months. But suddenly you meet server’s limits, like we did recently, and you have to decide whether to buy another metal or go back into the cloud. Buying second server has own pitfalls and might be tricky to maintain. Amazon’s EC2 might be an option, but manual management might be annoying (it was to me).

Here I wan’t to show you, how to manage EC2 instances using fog. I believe that crafting own, custom solution for such thing is good idea, because you can expect to have effects pretty fast.

In following posts I want to share knowledge which should help you to establish own toolset for managing your own mini-cloud based on AWS.

Goals

Each a little larger application can be divided into some logic parts, which might need to scale. In case of our app I’d do following split:

web workers
email workers (sending emails in background)
other background job workers
PostgreSQL
memcache
redis

In the beginning we will focus on scaling web and background workers. Problems with scaling databases come later, so we will deal with them in following posts.

Project setup

For our custom tool we will use Thor. It’s nicer than Rake and have more feature while it doesn’t have odd DSL in favor of ruby classes. Let’s create a project!


$ cd ~ && mkdir -p projects/mycloud
$ cd projects/mycloud

I use RVM, so I’ll setup RVM gemset:


$ rvm use 1.9.3-p327@mycloud --create
$ echo "rvm 1.9.3-p327@mycloud --create" > .rvmrc

I like bundler:


$ gem install bundler
$ bundle init

We need to install thor and fog, so put them into Gemfile and do bundle install

Let’s test thor. Create a node.thor file:


$ mkdir -p lib/tasks
$ touch lib/tasks/node.thor

Here is content for node.thor file:

class Node < Thor
  desc "up", "Creates an instance"
  def up
    puts "Instance created"
  end
end

You can easily test it in the terminal:


$ thor node:up
Instance created
$

And that’s it. We have simple project ready to grow.

Configuration

Our first task would be to boot an instance and ensure it’s connectivity. Before that we need to prepare configuration.

SSH keys

Go to Key Pairs section of Management Console (warning: link leads to EU West 1 zone!) and create new key pair. You will be prompted for name for keypair. Keys are created on per-region basis. My convention is to provide region name followed by user name (euwest1_sevos in my case).

Download your private key (I will use euwest1_sevos.pem as key file name) and place it in config/keys/ directory in our project. Remember to change rights to the key file to 600:


$ chmod 600 config/keys/*

credentials.yml

Go here and scroll to Access Credentials section. Grab AccessKey ID and Secret Access Key. We will need those to make API calls to AWS.

Create config/credentials.yml file for our credentials and commons:

aws_access_key_id: <your access key id>
aws_secret_access_key: <your secret access key>
region: eu-west-1
key_name: euwest1_sevos
ami: 'ami-c1aaabb5'
instance_type: 't1.micro'
security_group_name: 'mycloud'

Now, we can use these data to manage instances.

On AMI

I use current (as of writing this article) Ubuntu 12.04 64-bit AMI from EU West datacenter

On security group

Amazon uses security groups to protect instances from unwanted traffic. For sake of simplicity let’s create one security group opening port 22 (SSH) for world. Go to Security Groups and crete new group. Name it mycloud or whatever you’ll use later as security_group_name, provide description and leave VPC setting unchanged.

After creating security group set it up for accepting SSH connection.

Remember to click Add Rule and apply changes!

Booting an instance

Let’s edit up method and do some magic!

require 'yaml'
require 'fog'

class Node < Thor
  desc "up NAME", "Creates an instance"
  def up(instance_name)
    server = compute.servers.create(
        image_id:         config['ami'],
        flavor_id:        config['instance_type'],
        key_name:         config['key_name'],
        tags:             {
                            'Name' => instance_name
                          },
        groups:           config['security_group_name'],
        private_key_path: private_key_path
    )

    server.wait_for do
      ready?
    end

    say "Instance ready. You can connect to it using following command:", :green
    say "  ssh -i #{private_key_path} ubuntu@#{server.dns_name}"
  end

  private

  def compute
    @compute ||= Fog::Compute.new provider: 'AWS',
                                  region: config['region'],
                                  aws_access_key_id: config['aws_access_key_id'],
                                  aws_secret_access_key: config['aws_secret_access_key']
  end

  def config
    @config ||= YAML.load(File.read(File.join('config', 'credentials.yml')))
  end

  def private_key_path
    File.expand_path(File.join('config', 'keys', "#{config['key_name']}.pem"))
  end
end

Testing

Now it’s time to check our code. Type in the console:


$ thor node:up blog

After several seconds you should see similar message:


Instance ready. You can connect to it using following command:
ssh -i /Users/sevos/Projects/mycloud/config/keys/euwest1_sevos.pem
ubuntu@ec2-79-125-87-82.eu-west-1.compute.amazonaws.com

Just copy the SSH command and try to connect to the server. Note that even if server seems to be ready, sshd server might be not up yet. Just wait few seconds and try again.

Summary

That’s it for today. Turn off instance manually using AWS Console. Select an instance and from Actions menu select Terminate command.

We prepared a thor task for creating AWS instance from an AMI image. We still need some role-system, since we don’t care about single instance.

In next posts I will write also about provisioning and grouping instances.

Failing PostgreSQL on OS X

2012-09-17T00:00:00-07:00

Failing PostgreSQL on OS X

Today there will be only quick tip. Have you ever come back to work on monday and seen following error after lanunching your Rails development:


could not connect to server: Connection refused (PG::Error)
        Is the server running on host "localhost" (::1) and accepting
        TCP/IP connections on port 5432?
could not connect to server: Connection refused
        Is the server running on host "localhost" (127.0.0.1) and accepting
        TCP/IP connections on port 5432?
could not connect to server: Connection refused
        Is the server running on host "localhost" (fe80::1) and accepting
        TCP/IP connections on port 5432?

If you installed PostgreSQL via homebrew, you might want try removing postmaster.pid, what helped me:


rm /usr/local/var/postgres/postmaster.pid

Separate your concerns

2012-01-13T00:00:00-08:00

Separate your concerns

This post is written in response to Keep your privates close of Thoughtbot

At the beginning I must admit that previously I have never thought, that we could use private keyword in THIS way. First time I met this approach in my new outsourced project with code written by former devs. When I opened random file, I saw ugliness written in following style:

class User < ActiveRecord::Base
  has_many :tickets
  has_many :events

  # -------------------------------------
  # Recent tickets
  # -------------------------------------
  def most_recent_ticket
    # huh, obviously code here
  end

  def recent_tickets

  end
  private :recent_tickets

  # more public and private methods
  # …

  # -------------------------------------
  # API Keys
  # -------------------------------------
  after_create :create_api_keys

  def create_api_keys

  end
  private :create_api_keys

  def random_key

  end
  private :random_key
end

I hope, you’ve got the idea. When I asked why do we need to follow this convention, I’ve got answer that this solves problem of vertical distance between public and private methods related to each other. It was surprise for me, because usually I put FIXME comment in large files.

During discussion my opponent sent me a link to the mentioned blog post from Thoughtbot. After reading it I must agree with author at one point.

Vertical distance is bad

First programs ever written had mostly one file. Developers were helping themselves by separating code with comments. Later file inclusion has been introduced enabling developers to split code into several files. Then came functions, namespaces, classes and modules. Everything what makes the code more readable and beautiful.

It is not only about look&feel. The code, we write, should be maintainable.

Someone said once that you should always keep in mind that developer coming after you is psychopath, who knows, where do you live. It might be just you, after few months. Making code maintainable reduces costs of project. It’s okay to not care about that when prototyping, but is not when you write a real project, especially an for external client.

Let’s get to the point

The need of grouping methods together exposes something to us. Usually we group them by some concern, which corresponds to a part of object’s responsibilities. This mean that object, when realizing those responsibilities, plays a role in our system. Yea, I know, you may think now, that I am next guy selling DCI or some other pattern. DCI is in fact quite nice solution, but I really don’t care how do you split your code, unless it is technique from previous century.

When your class is getting bigger, you can easily extract concerns into separate module. Your main file becomes a list of contents. First step of refactoring of example above would be following:

# app/models/user.rb
class User < ActiveRecord::Base
  include Tickets
  include ApiKeys

  has_many :events
end

# app/models/user/tickets.rb
module User::Tickets
  extend ActiveSupport::Concern

  included do
    has_many :tickets
  end

  def most_recent_ticket
    # huh, obviously code here
  end

  private
    def recent_tickets

    end
end

# app/models/user/api_keys.rb
module User::ApiKeys
  extend ActiveSupport::Concern

  included do
    after_create :create_api_keys
  end

  private
    def create_api_keys

    end

    def random_key

    end
end

For me it is much better. Please note that this approach is in early stage and few things should be discussed, like:

should we use ActiveSupport::Concern and extract relations to modules?
should we include at class’ level or extend on object’s level? (Personally if comes to AR classes I preffer includes - I agree that DCI at AR level is wrong)
how we deal with common code?
how to deal with load_missing_constant ambiguous behaviour?
It happens when you name your nested models like classes or modules being visible in global scope, consider User::Ticket and Ticket. Rails somehow fallbacks to ::Ticket when including User::Ticket. I bypass this by writing require_relative 'user/ticket' and include User::Ticket. I know, it is not perfect but good enough for now.

What’s next?

Often we get to the point, when a model in our projects grows too big. We did tend always to follow Skinny controller, fat model principle, but models have got extremely big - I saw files with 300 LoC, who bids more? Of course, we can live with that. We can also live without dishwashers and RSS (both are big time savers to me).

After separating your concerns, you may discover that persistence is also a concern. This will change the way you think about domain models drastically. I haven’t get to this point or/and I am not brave enough yet to experiment with PORO models in projects for external clients, but for sure I will give it a try in my next side-project. However this is topic for next post ;-).

Some of you may think, why bother? Ruby is beautiful. Most of use came here from Java, PHP and other languages. Ruby let us express our thoughts easier than many of them. Let’s don’t break this with ugly spaghetti code. Don’t go back.

DCI doubts

2011-10-06T00:00:00-07:00

DCI doubts

Background: I am working on an application which brings new user interface for legacy system used by customer. There is basic model in the legacy system: Department. My customer wants to see several statistics related to each of his departments. That’s my duty.

As I started modelling business domain in my app I wanted to keep things as simple as possible. I wanted also try out DCI finally. Time had come ;-)

My first idea was to create Department model and let it to play roles in the app (bad idea, but keep reading):

class Department << ActiveRecord::Base
end

class DepartmentsController
  def update_stock_value
    stock = Department.find(params[:id]).extend Roles::Stock
    stock.update
  end
end

module Roles
  module Stock
    def update
      # fetch value from external application and store
    end

    def value
      stock_value
    end
  end
end

However I realized that there was something missing. Obviously there was missing a relation that Department certainly has one Stock. Just like that. I was copying business model from legacy app instead of creating new model for this domain.

I am going to refactor that piece of code and I have two choices:

Keep going with DCI and let only actors to play roles

class StocksController
  def update
    stock = Stock.where(:department_id => params[:department_id]).first
    current_user.extend Role::StockManager
    current_user.update stock
  end
end

module Roles::StockManager
  def update(stock)
    stock.update_attribute :value,
                           Legacy::Department.find(stock.department.id).stock_value
  end
end

class Department < ActiveRecord::Base
  has_one :stock
end

class Stock < ActiveRecord::Base
  belongs_to :department
end

class Legacy::Department < ActiveResource::Base
  # stuff here
end

Second option was to go back to class-oriented paradighm:

class Department < ActiveRecord::Base
  has_one :stock
end

class Stock < ActiveRecord::Base
  belongs_to :department

  def update
    update_attribute :value, Legacy::Department.find(department.id).stock_value
  end
end

class Legacy::Department < ActiveResource::Base
  # stuff here
end

class StocksController
  def update
    Stock.where(:department_id => params[:department_id]).first.udpate
  end
end

My main concern is that DCI in those examples looks like to complex to me. Why we shouldn’t place more emphasis on better model granulation? If comes to the classic example with e-commerce: an user as a buyer: why we can’t use classic decorator pattern? Buyer might be a model being a decorator for User model. And that’s it, no roles, no additional layer.

KPI gem

2011-05-15T00:00:00-07:00

KPI gem

Clients for whom I worked, at some stage of the are almost always asked me to create statistics describing the status and dynamics of development. The simplest example is number of registered users, but with time it always get more complex.

I decided to build a small library in order to have common way of defining the statistics among my projects. Gem statistics gives not enough freedom to me. I need to be able to define reports having complex row definitions and reports made of other reports.

First I developed gem with ActionMailer support (with simple report email), but recently my another client asked me for statistics in rails 2.3.x project. Then problems with compatibility came up, so I decided to remove ActionMailer support completely. The gem delivers only possibility to build reports as ruby objects now. You should create views for those on your own.

Example report:

class DailyStatsReport < KPI::Report
  def users
    result 'Users', User.count, :description => 'Total users count'
  end

  def premium_users
    result 'Premium users', User.premium.count
  end

  def premium_users_percentage
    result 'Premium users', premium_users.to_f / users * 100, :unit => '%'
  end

  def income
    result 'Total income', Order.paid.sum(:total), :unit => 'EUR'
  end

  def daily_income
    result 'Daily income', Order.paid.where(:created_at => the_day).sum(:total), :unit => 'EUR'
  end

  private

  def the_day
    @yesterday ||= begin
      yesterday = (time - 1.day)
      yesterday.beginning_of_day..yesterday.end_of_day
    end
  end
end

You can get report by instantiating report class

report = DailyStatsReport.new

Each value is cached after calculation while report object exists. Calling report methods will trigger calculation and return KPI::Entry object:


> report.users
=> #<KPI::Entry:0x10177f630 @name="Users", @unit=nil,
     @description="Total users count", @value=874>

KPI::Report provides enumerator #entries allowing to iterate through report entries:


> report.entries.map(&:value)
=> [874, 14, 138.6, 19.8]

In order to get report for previous day, you should pass :time option to report initializer:

report = DailyStatsReport.new(:time => 1.day.ago)

NOTE: In entry definitions you should not use Time.now for determining current time, use self.time instead.

But that’s not all! Stay tuned!

There is another class KPI::MergedReport. It takes reports of the same type and merges them using function passed through block:

report_today = DailyStatsReport.new
report_yesterday = DailyStatsReport.new(:time => 1.day.ago)
diff_report = KPI::MergedReport.new(report_today, report_yesterday) do |entry_today, entry_yesterday|
  KPI::Entry.new '$$ (change)', entry_today.value - entry_yesterday.value
end

NOTE: For now unfortunately it is not possible to use result helper in that block. I am working on that.

Now, we can get differences between reports:


> diff_report.premium_users
=> #<KPI::Entry:0x11577e319 @name="Premium users (change)",
     @unit=nil, @description="", @value=2>

Actually it is not problem to pass more reports and calculate average value for example:

avg_report = KPI::MergedReport.new(*week_reports) do |*entries|
  KPI::Entry.new '$$ (avg)', entries.map(&:value).inject(:+).to_f / entries.size
end

When you have your report object, you might want to send an email with data provided by it or do something else. That’s all for now. Check it out on Github! All ideas and comments are welcome!

KPI gem sourcecode on github

Facebook Integration In Rails 3 Using Omniauth

2011-02-10T00:00:00-08:00

Warning: This blog post was originaly written in February 2011. Since that time OmniAuth 1.x has been released and it’s API has been changed. Please refer to OmniAuth wiki for further details

Facebook integration in Rails 3 using OmniAuth

Recently I faced a task of integrating Facebook and Twitter into my application. I wanted to let users sign up and sign in by their social network accounts. My application does not require any special information to create an account - just an email address. I dug a bit and found that the best fit for me was OmniAuth. I also found great railscast (and part two) made by Ryan Bates. My solution is based mostly on these two screencasts.

The code shown by Ryan was just a hint, how it should be done. Few cases, like attaching already used authentication, were not covered in the screencasts. And today I would like to share with you my solution. It covers most cases, except removing last authentication from user’s account. It is up to you, what you will do with that. In my application, after removing last authentication, user can still reset his password via email. You might want to just remove account.

Enjoy!

app/controllers/authentications_controller.rb:

class AuthenticationsController < ApplicationController
  before_filter :authenticate_user!, :only => :destroy

  def create
    omniauth = request.env['omniauth.auth']
    authentication = Authentication.find_by_provider_and_uid(omniauth["provider"], omniauth["uid"])
    if current_user
      if authentication && authentication.try(:user) != current_user
        flash[:error] = I18n.t("This %{provider} account is already connected to another account in our service", :provider => authentication.provider)
      elsif authentication.nil?
        current_user.authentications.create!(:provider => omniauth["provider"], :uid => omniauth["uid"])
      end
      redirect_to edit_user_registration_path(current_user)
    else # user logged out
      if authentication # sign in user
        sign_in_and_redirect :user, authentication.user
      else # create new user
        user = User.new.tap {|user| user.apply_authentication(omniauth) }
        if user.save
          sign_in_and_redirect :user, user
        else
          session["omniauth"] = omniauth
          redirect_to new_user_registration_path
        end
      end
    end
  end

  def destroy
    @authentication = current_user.authentications.find(params[:id])
    @authentication.destroy
    redirect_to :back
  end
end

app/models/authentication.rb:

#  create_table "authentications", :force => true do |t|
#    t.integer  "user_id"
#    t.string   "provider"
#    t.string   "uid"
#    t.datetime "created_at"
#    t.datetime "updated_at"
#  end

class Authentication < ActiveRecord::Base
  belongs_to :user
  validates :uid, :provider, :presence => true
  attr_accessor :raw

  def email
    self.raw["user_info"]["email"]
  rescue
  end
end

config/initializers/omniauth.rb

file_name = File.join(File.dirname(__FILE__), "..", "authentication_services.yml")
OMNIAUTH_KEYS = YAML.load(ERB.new(File.new(file_name).read).result)[Rails.env].freeze

Rails.application.config.middleware.use OmniAuth::Builder do
  OMNIAUTH_KEYS.each do |prov, config|
    provider prov, *config
  end
end

config/authentication_services.yml

development:
  facebook:
    - '55a66eefce926c2eb1412222bc04f2787'
    - '2f64ae3613398a553ecccc0da9f75a2b'
    - scope: 'email'
  twitter:
    - 'j7WltZaDVaNcGB8n28aa'
    - 'Rs0zOf1yUaybs1AMW77Ahc2x11KaZWfX2q7ohU'
test:
  facebook:
    - 'test'
    - 'test'
production:
  facebook:

spec/controllers/authentications_controller_spec.rb:

require 'spec_helper'

describe AuthenticationsController do
  before { @user = Factory(:user) }

  describe "POST / from facebook" do
    before do
      @omniauth = {
        'uid' => "12345",
        'provider' => "facebook"
      }
      request.env["omniauth.auth"] = @omniauth
    end

    context "user logged in" do
      before do
        sign_in @user
      end
      context "having no authentications" do
        it "should create authentication " do
          post :create
          @user.reload.should have(1).authentication
        end

        it "should redirect to user's profile" do
          post :create
          response.should redirect_to(edit_user_registration_path(@user))
        end
      end

      context "having facebook authentication" do
        before { @user.authentications.create!(:provider => "facebook", :uid => "12345")}
        it "should not create authentication  " do
          post :create
          @user.reload.should have(1).authentication
        end

        it "should redirect to user's profile" do
          post :create
          response.should redirect_to(edit_user_registration_path(@user))
        end
      end

      context "facebook authentication connected to another account" do
        before do
          @another_user = Factory(:user)
          @another_user.authentications.create!(:provider => "facebook", :uid => "12345")
        end

        it "should disallow to connect accounts" do
          post :create
          @user.reload.should have(0).authentications
          flash[:error].should == "This facebook account is already connected to another account in our service"
          response.should redirect_to(edit_user_registration_path(@user))
        end
      end
    end

    context "user logged out" do
      context "user has attached authentication", "and logging in" do
        before { @user.authentications.create!(:provider => "facebook", :uid => "12345") }
        it "should sign in user" do
          post :create
          controller.send(:current_user).should == @user
        end

        it "should redirect" do
          post :create
          response.should be_redirect
        end
      end
    end

    context "no matching user" do
      context "no extra credentials given" do
        before do
          @user = User.new
          @user.stub!(:save => false)
          User.stub!(:new => @user)
        end

        it "should apply authentication" do
          @user.should_receive(:apply_authentication).with(request.env["omniauth.auth"])
          post :create
        end

        it "should save authentication to session" do
          post :create
          session[:omniauth].should == @omniauth
        end

        it "should redirect to new registration path" do
          post :create
          response.should redirect_to(new_user_registration_path)
        end
      end

      context "facebook credentials given" do
        before { request.env["omniauth.auth"]["user_info"] = {"email" => "example@example.com"} }

        it "should create user" do
          -> { post :create }.should change(User, :count).by(1)
        end

        it "should sign in created user" do
          post :create
          controller.send(:current_user).should_not be_nil
        end

        it "should redirect" do
          post :create
          response.should be_redirect
        end
      end
    end
  end
end

spec/models/authentication_spec.rb

require 'spec_helper'

describe Authentication do
  describe :email do
    context "for facebook" do
      before { @auth = Authentication.new(:provider => 'facebook') }
      it "from raw" do
        @auth.raw = {'user_info' => {'email' => 'artur.roszczyk@gmail.com'}}
        @auth.email.should == 'artur.roszczyk@gmail.com'
      end
    end
  end
end

Github Gist is available here

iWork '09 Retail after trial

2010-10-26T00:00:00-07:00

iWork ‘09 Retail after trial

Perhaps you installed iWork ‘09 trial in order to give it a chance. Perhaps you was amazed by this great suite and wanted to use it also after 30 days period. If you live, like me, in country where you cannot buy an online CD-Key, you have to go to retail store or Apple reseller and buy a retail version of iWork ‘09. And that’s what I did.

Unfortunately when I came back to home, opened the box and installed suit from DVD, it was not been working. After launching Pages I got request for CD-Key. WTF? I asked uncle Google and got to know that Apple didn’t require any serials for retail disc installations.

Solution:

Go to your Applications directory
Drag iWork ‘09 directory to the bin
Open you Macintosh HD directory (just root directory) and go to Library
Open Application support folder
Drag iWork ‘09 folder to the trash bin
Empty your trash bin
Proceed with standard installation from retail disc

I hope that it will help you. I wasted 15 minutes for finding this solution.

The Passionate Programmer

2010-08-19T00:00:00-07:00

The Passionate Programmer

A couple of months ago I have bought an e-book written by Chad Fowler. It tells mostly about responsible, aware career planning from developer’s point of view. At least it seems to tell about that. In fact, if we cut off the domain-specific examples, it becomes a vast hanbook explaining how to cultivate our happines, life pleasure.

The author stands that your live, in general, is filled with your work. Therefore you need to draw satisfaction from your job and enjoy it. He uses his story as an example to show how flexible, foreseeing and enthusiastic about your job you should be in order to achieve succes. Huge impact is put on business point of view, so much misunderstood in IT industry. In the book you are treated as a product, which you are going to sell to your present/future employers or clients.

The book is divided into five parts:

Choosing Your Market
Investing in Your Product
Executing
Marketing…Not Just for Suits
Maintaining Your Edge

You can read more about this book on Pragmatic Bookshelf site here

I am going to write about my experience in applying these hints in my life.