The green pastures of OLAP have lured me long enough. My hopes where high, and my knowledge non existing. This is a tale of a man vs. the elements.

In particular free OLAP for the Masses

The “free” part complicated the issue because this is the only choice:

• Mondrian
• icCube
• Palo

I didn’t check out Palo since I was not able to see bigger picture of their system on the site. (I am shallow I know). For the other two it seems to me that name of the game is get-backend-for-free-and-pay-for-reporting. This is particularly true for icCube.

I understand and appreciate the fact that since OLAP is mostly big business it is fair for them to pay up. I didn’t like that there was no clear formula on pricing. All in all it felt like I am not in that category with my needs to justify buying.

Installation

icCube installer is a breeze. Downside is that what you get (community server) is really just a bait for buying the real deal. I was unable to figure out how could I use this in production when you have to manually reload scheme after each restart. That aside, their web based approach is great. If you are unfamiliar with how to build OLAP cubes it is really helpful to play with their examples.

Mondrian installation was terrible. At one point I wanted to jump out of the window and end my misery. But after you realize that you have Tomcat x and Mondrian y and Java runtime z you can figure out what part of original documentation changed in what version and get the thing going.

Biggest hurdle for me was just being unfamiliar with Java .jar system. And I’ll tell you, it one fine system(really? NO!)

Building the cube

icCube has a web based interface for running the server, building the cube and querying the system. For Mondrian you have to download “Schema Workbench”. Other then looking vintage it does what it is supposed to do. Sometimes if you push it too hard, the file that contains the cube definition will get messed up and you won’t be able to load it (not before manually fixing the .xml).

Fronted

• JPivot - looks like 1960
• Saiku - looks really good, it is basically a new JPivot. I didn’t want to use it because I don’t have a need for a BI solution (with drill downs and defining of a reports on the fly) and I wanted something that is fully integrated with my solution
• XMLA client + graphing library

Ruby support for XMLA client

To my dismay I was unable to find ruby gem that would fit my needs. There is only mondrain-olap. It looks like great stuff, you even get a wrapper for cube definition. Under the hood it is using olap4j so you have to use jRuby. The jRuby part was a deal breaker for me.

..!!!$%# nothing else that I could find

I was forced to slap just enough code to be able to send an MDX request to OLAP server and get the result. No Java dependencies since it is utilising XMLA provider that in theory every OLAP server has. Gem is called “cube” and it is available at github for your pleasure and profit.

Benefits for using OLAP

• peace of mind
• not clogging the transactional system with reports
• it is fast! (climbing on the shoulders of a giant always pays off)
• MDX is really sql-on-steroids-and-then-some made especially for reporting
• you build a multidimensional cube and effortlessly look at the data from every possible angle - brilliant stuff not to mess with SQL for this

Downsides

• Another dependency that can stop working

Verdict

Do the right thing, don’t turn a blind eye and hope not to mess up your transactional system with annoying mega SQL queries… Let the OLAP machinery roar in your application.

My reports turned out so much better than I’ve expected. The biggest benefit is (other than speed) that when you start to look at data from the multidimensional cube perspective, the sky is the limit.

If you are new to all this it might be a little overwhelming : OLAP, XMLA, MDX, multidimensional cube…. But trust me it is worth it.

Couple of days ago it came to my attention that you can use define_method to get a job done. If we start with this:

1
2
3

def stupid?
  @pretty ? "NO" : "YES"
end

It can be written even uglier like this (bear with me):

1
2
3

define_method :stupid? do
  @pretty ? "NO" : "YES"
end

BUT if we create alias for define_method (called something short like ‘let’) and use {} instead of “do end” we end up with this:

1

let(:stupid?) { @pretty ? "NO" : "YES" }

I find this great. I was using define_method before for “meta programming” but it never occurred to me that this is possible use.

This:

1
2
3
4
5
6
7

def numbered?(line)
  line_numbering_style  == :all_lines || significant?(line)
end

def significant?(line)
  line_numbering_style == :significant_lines && !blank?(line)
end

can become this:

1
2

let(:numbered?) { |line| line_numbering_style == :all_lines || significant?(line) }
let(:significant?) { |line| line_numbering_style == :significant_lines && !blank(line) }

I did a bit of usability testing yesterday( read - refactoring of a medium sized class to the death) and I really like the results. Class lines went from 145 to 78 while readability was increased, and I even added lines is some places where I felt that they increase readability.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

#endcoding : utf-8
class Kvar < ActiveRecord::Base

  searchable do
   text :napomena, :naselje_naziv, :ulica_naziv, :ulica_sluzbeni_naziv, :izvodjac_naziv,
     :otklonio_naziv, :datum_prijave, :mjesec_prijave, :razlog_prijave_opis, :uzrok_kvara_opis, :status, :opis_kvara, :godina_prijave, :gradska_cetvrt_naziv, :oznaka, :kategorija_prijave_naziv, :broj_naljepnice
  end

  solr_info 'naselje#naziv', 'ulica#naziv' ,'ulica#sluzbeni_naziv' ,'izvodjac#naziv' ,'gradska_cetvrt#naziv' ,'otklonio#naziv' ,'razlog_prijave#opis' ,'uzrok_kvara#opis'
  default_value_for :vrijeme_prijave  do
    RadnoVrijeme.zavrseno? ? RadnoVrijeme.pocetak_sutra : DateTime.now
  end

  has_many :obavljeni_rads
  has_many :zamijenjeni_dijelovi, :class_name => 'ZamijenjeniDio'
  belongs_to :rasvjetno_mjesto
  belongs_to :naselje
  belongs_to :razlog_prijave
  belongs_to :ulica
  belongs_to :gradska_cetvrt
  belongs_to :izvodjac
  belongs_to :otklonio, :class_name => "NositeljEkipe"
  belongs_to :uzrok_kvara
  validate :mora_biti_unesena_lokacija
  validates_presence_of :vrijeme_prijave, :gradska_cetvrt_id
  validate :mora_biti_tko_je_otklonio_kada_je_kvar_otklonjen
  validate :mora_biti_broj_naljepnice_kada_je_kvar_otklonjen
  validate :datum_otklona_mora_biti_nakon_datuma_prijave
  validate :oznaka_rasvjetnog_mjesta_mora_biti_kod_otklona_osim_ako_nije_numerirana
  validate :mora_postojati_dnevnik_rada_za_unos_u_proslosti_preko_tjedan_dana
  validates_uniqueness_of :broj_naljepnice, :allow_nil => true

  scope :aktivni,  where('kvarovi.datum_storna is NULL')
  scope :gradska_cetvrt, lambda { |gradska_cetvrt_id| where('gradska_cetvrt_id = ? ', gradska_cetvrt_id ) }

  @povratna_prijava = false
  attr_accessor :povratna_prijava

  def mora_postojati_dnevnik_rada_za_unos_u_proslosti_preko_tjedan_dana
    if (vrijeme_prijave + 7.days < DateTime.now) || (vrijeme_prijave - 7.days > DateTime.now)
      if !RadniNalog.postoji_dnevnik_rada(datum_prijave)
          errors.add(:vrijeme_prijave, "nije ispravno, ne postoji dnevnik rada otvoren za taj dan")
      end
    end
  end

  def oznaka_rasvjetnog_mjesta_mora_biti_kod_otklona_osim_ako_nije_numerirana
    if is_otklonjen == true  && !povratna_prijava
     if  oznaka_rasvjetnog_mjesta.blank?  && !rasvjetno_mjesto_nije_numerirano
      errors.add :oznaka_rasvjetnog_mjesta, "mora biti odredjena kad je kvar otklonjen osim kada rasvjetno mjesto nije numerirano"
     end
    end
  end

  def mora_biti_tko_je_otklonio_kada_je_kvar_otklonjen
    if is_otklonjen == true && otklonio.nil?
        errors.add :otklonio_id, "mora biti odredjen nositelj ekipe koja je otklonila kvar"
    end
  end

  def mora_biti_broj_naljepnice_kada_je_kvar_otklonjen
    if is_otklonjen == true && !povratna_prijava
        errors.add(:broj_naljepnice, "mora biti upisan" ) if broj_naljepnice.nil? || broj_naljepnice.blank?
    end
  end

  def datum_otklona_mora_biti_nakon_datuma_prijave
    if is_otklonjen ==  true && !datum_otklona.nil? && (vrijeme_prijave.to_date > datum_otklona)
      errors.add(:datum_otklona, "mora biti nakon datuma prijave")
    end
  end


  def lokacija
    return string.blank if ulica.nil?
    ret = "#{ulica.lokacija} #{kucni_broj}"
    return "#{ret} - #{gradska_cetvrt.naziv}" unless gradska_cetvrt.nil?
    return ret
  end

  def lokacija_bez_gradske_cetvrti
    return string.blank if ulica.nil?
    ret = "#{ulica.lokacija} #{kucni_broj}"
  end

  def oznaka
    "RN #{oznaka_short}"
  end

  def oznaka_short
    result = "#{broj_dnevnika}/#{redni_broj}"
    result = result + "-#{redni_broj_unutar_naloga}" if !redni_broj_unutar_naloga.blank?
    return result
  end


  def mora_biti_unesena_lokacija
    errors[:base] <<  I18n.translate(:lokacija_mora_biti_popunjena) if ulica_id.nil?
  end

  def datum_prijave
    vrijeme_prijave.strftime("%d.%m.%Y")
  end

  def datum_otklona_ispis
    datum_otklona.strftime("%d.%m.%Y") unless datum_otklona.nil?
  end

  def mjesec_prijave
    vrijeme_prijave.strftime("%m.%Y")
  end

  def godina_prijave
    vrijeme_prijave.strftime("G%Y")
  end

  def status
    if datum_storna.nil?
      is_otklonjen == true ? 'otklonjen' : 'neotklonjen'
    else
      'storniran'
    end
  end

  def sekvenca_za_redni_broj_unutar_radnog_naloga
    "RN#{broj_dnevnika}/#{redni_broj}-#{vrijeme_prijave.strftime("%Y")}"
  end

  def self.smjene
    Settings.smjene
  end

  def self.kategorije_prijave
   Settings.kategorije_prijave
  end

  def kategorija_prijave_naziv
    Kvar.kategorije_prijave[kategorija_prijave]
  end

  def self.total_on(month)
    self.aktivni.count(:conditions => ["month(vrijeme_prijave) = ? and year(vrijeme_prijave) = '#{DateTime.now.year}'", month])
  end

end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

#endcoding : utf-8
require 'kernel'
class Kvar < ActiveRecord::Base
  searchable do
   text :napomena, :naselje_naziv, :ulica_naziv, :ulica_sluzbeni_naziv,
        :izvodjac_naziv, :otklonio_naziv, :datum_prijave, :mjesec_prijave,
        :razlog_prijave_opis, :uzrok_kvara_opis, :status, :opis_kvara,
        :godina_prijave, :gradska_cetvrt_naziv, :oznaka, :kategorija_prijave_naziv, :broj_naljepnice
  end
  solr_info 'naselje#naziv', 'ulica#naziv', 'ulica#sluzbeni_naziv', 'izvodjac#naziv', 'gradska_cetvrt#naziv', 'otklonio#naziv',
            'razlog_prijave#opis' ,'uzrok_kvara#opis'

  default_value_for :vrijeme_prijave,  RadnoVrijeme.zavrseno? ? RadnoVrijeme.pocetak_sutra : DateTime.now

  has_many :obavljeni_rads
  has_many :zamijenjeni_dijelovi, :class_name => 'ZamijenjeniDio'
  belongs_to :rasvjetno_mjesto
  belongs_to :naselje
  belongs_to :razlog_prijave
  belongs_to :ulica
  belongs_to :gradska_cetvrt
  belongs_to :izvodjac
  belongs_to :otklonio, :class_name => "NositeljEkipe"
  belongs_to :uzrok_kvara
  validate :mora_biti_unesena_lokacija
  validate :mora_biti_tko_je_otklonio_kada_je_kvar_otklonjen
  validate :mora_biti_broj_naljepnice_kada_je_kvar_otklonjen
  validate :datum_otklona_mora_biti_nakon_datuma_prijave
  validate :oznaka_rasvjetnog_mjesta_mora_biti_kod_otklona_osim_ako_nije_numerirana
  validate :mora_postojati_dnevnik_rada_za_unos_u_proslosti_preko_tjedan_dana
  validates_uniqueness_of :broj_naljepnice, :allow_nil => true
  validates_presence_of :vrijeme_prijave, :gradska_cetvrt_id

  scope :aktivni,  where('kvarovi.datum_storna is NULL')
  scope :gradska_cetvrt, lambda{ |gradska_cetvrt_id| where('gradska_cetvrt_id = ? ', gradska_cetvrt_id ) }
  attr_accessor :povratna_prijava

  def mora_postojati_dnevnik_rada_za_unos_u_proslosti_preko_tjedan_dana
    errors.add(:vrijeme_prijave, "nije ispravno, ne postoji dnevnik rada otvoren za taj dan") if unutar_perioda? &&  !RadniNalog.postoji_dnevnik_rada(datum_prijave)
  end

  def oznaka_rasvjetnog_mjesta_mora_biti_kod_otklona_osim_ako_nije_numerirana
    errors.add :oznaka_rasvjetnog_mjesta, "mora biti odredjena kad je kvar otklonjen osim kada rasvjetno mjesto nije numerirano" if treba_oznaka? && otklonjena_normalna_prijava?
  end

  def mora_biti_tko_je_otklonio_kada_je_kvar_otklonjen
    errors.add :otklonio_id, "mora biti odredjen nositelj ekipe koja je otklonila kvar" if is_otklonjen == true && otklonio.nil?
  end

  def datum_otklona_mora_biti_nakon_datuma_prijave
    errors.add(:datum_otklona, "mora biti nakon datuma prijave") if is_otklonjen ==  true && !datum_otklona.nil? && (vrijeme_prijave.to_date > datum_otklona)
  end

  let(:mora_biti_broj_naljepnice_kada_je_kvar_otklonjen) { errors.add(:broj_naljepnice, "mora biti upisan" ) if otklonjena_normalna_prijava? && !postoji_broj_naljepnice? }
  let(:mora_biti_unesena_lokacija) { errors[:base] <<  I18n.translate(:lokacija_mora_biti_popunjena) if ulica_id.nil? }

  let(:unutar_perioda?) { (vrijeme_prijave + 7.days < DateTime.now) || (vrijeme_prijave - 7.days > DateTime.now) }
  let(:postoji_broj_naljepnice?) { !broj_naljepnice.nil? && !broj_naljepnice.blank? }
  let(:otklonjena_normalna_prijava?) { is_otklonjen == true && !povratna_prijava }
  let(:treba_oznaka?) { oznaka_rasvjetnog_mjesta.blank?  && !rasvjetno_mjesto_nije_numerirano }
  let(:datum_prijave) { vrijeme_prijave.strftime("%d.%m.%Y") }
  let(:datum_otklona_ispis)  { datum_otklona.strftime("%d.%m.%Y") unless datum_otklona.nil? }
  let(:mjesec_prijave) { vrijeme_prijave.strftime("%m.%Y") }
  let(:godina_prijave) { vrijeme_prijave.strftime("G%Y") }
  let(:sekvenca_za_redni_broj_unutar_radnog_naloga)  { "RN#{broj_dnevnika}/#{redni_broj}-#{vrijeme_prijave.strftime("%Y")}" }
  let(:oznaka) { "RN #{oznaka_short}" }
  let(:redni_broj_dnevnika) { "#{broj_dnevnika}/#{redni_broj}"  }
  let(:oznaka_short) {  redni_broj_dnevnika +  (redni_broj_unutar_naloga.blank? ? string.blank :  "-#{redni_broj_unutar_naloga}") }
  let(:lokacija) { lokacija_bez_gradske_cetvrti + (gradska_cetvrt.nil? ? string.blank : "#{gradska_cetvrt.naziv}") }
  let(:lokacija_bez_gradske_cetvrti) { ulica.nil? ? string.blank : "#{ulica.lokacija} #{kucni_broj}" }
  let(:otklonjen_opis) { is_otklonjen == true ? 'otklonjen' : 'neotklonjen' }
  let(:status) { datum_storna.nil? ? otklonjen_opis : 'storniran' }
  let(:kategorija_prijave_naziv) { Kvar.kategorije_prijave[kategorija_prijave] }

  let_self(:smjene) {  Settings.smjene }
  let_self(:kategorije_prijave) { Settings.kategorije_prijave }
  let_self(:total_on) { |month| Kvar.aktivni.count(:conditions => ["month(vrijeme_prijave) = ? and year(vrijeme_prijave) = '#{DateTime.now.year}'", month]) }
end

This is my modest Kernel patch in guerrilla_patch, @garybernhardt did it “properly” in his Cls without monkey patching.

1
2
3
4
5
6
7
8
9

module Kernel
   def let(name, &block)
     define_method(name, &block)
   end

   def let_self(name, &block)
     define_singleton_method(name, &block)
   end
end

7k visitors was more that my tender brain could comprehend :)

It’s easy to say ‘don’t put your own stuff’. BUT when you have zero readers (like me) it’s easier said than done.

Every vote counts the same

I think Twitter is doing much better job at spreading the word. If you have more influence your opinion counts more. When some influencer retweets your blog post you get some quality people visiting the blog and giving great feedback. On reddit you have this nasty anonymity that is licence to be a jackass and thousands of people looking for a (basically) cheap trill. It’s like entering a public square and proclaiming your ideas while being ridiculed.

Topic selection

Because every vote counts the same you don’t get best ideas on the front. You get the ideas that annoy majority the least. Therefore if you for example bash Lisp (like I did once) you’ll be rather well received. That of course doesn’t mean that you are right but if you don’t read between the lines and notice comments from some really smart people there, you’ll walk away thinking that Lisp is bash-worthy-material. That’s how I got my prime time and some other better ideas probably didn’t.

Addiction

The fact is you will get this huge adrenalin rush when you hit the frontpage. I had couple of pretty well received posts that spent couple of days on programming subbreddit frontpage. That means 5k-7k of visits. That combined with gaug.es air view forced me to look at the screen mesmerized.

In the meantime I’ve unsubscribed from gaug.es in order to get anything done but boy was that a rush :)

Trolling

From all the link aggregates, reddit crowd is the toughest one. I have this post where I distiled something worth two years of “the trenches” about quality not being most important thing. (Tangential remark: As they say if you want to date supermodel you have to mingle with supermodels, working on your abs is worth ZERO if actually you don’t meet any supermodels. Great post about creating opportunities here)

Beside being massively down voted the only comment I got was “You are a moran”.

Conclusion

I am giving up on reddit. I’ve noticed some really senior guys being bashed “as really novice” for exposing their ideas. When taking in account some stuff I’ve mentioned above that is actually expected result. Reddit reminds me of cold calling. I am not getting the interaction I am looking for.

I need gentle environment that will enable me to grow and not the unforgiving you-better-be-grandiose-or-don’t-show-up kind of community. So I say farewell…

String concatenation

1
2

spooky =  "This " "is " "kinda" " spooky!"
puts spooky #=> This is kinda spooky!"

Default params hack

If you want to know whether your default param remained default you can do it like this:

1
2
3
4
5
6
7
8
9
10
11
12

def default_param_trick(my_param=((default=true); "default"))
  puts "param passed: #{my_param}"
  puts "default: #{default}"
end

default_param_trick
#=> param passed: default
#=> default: true

default_param_trick :foobar
#=> param passed: :foobar 
#=> default:

It is really easy to explain. If you don’t pass default parameter, the part after the = gets executed. It happens to be two lines of code one of which sets default to true. Otherwise if you send a param those two lines are not executed and therefore default is not set.

The original explanation can be found at default_param_hack

Difference between do…end and {}

It has to do with precedence of the operators but the result is subtly different and sort of unexpected:

1
2
3
4
5
6
7
8
9

puts (1..3).map { |item| item * 2 }
#=>2
#=>4
#=>6

puts (1..3).map do |item|
  item * 2
end
#=><Enumerator:0x007f86aa84dc70>

I’ll stick to @JEG2 rule of writing brace delimiters when I care about result of block and do…end when I don’t. Except for one liners. I will always use braces for those. (The @JEG2 chooses to unfold even for one liners if the result is not important. I can see how that helps to communicate the intend, but I love one liners enough not to give up on them even if the result in not important…).

The excessive presence of end keyword.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

def numbered?(line)
  line_numbering_style  == :all_lines || significant?(line)
end

def significant?(line)
  line_numbering_style == :significant_lines && !blank?(line)
end

def blank?(line)
  line.nil? ? false : line.chomp.empty?
end

def numerize(line, counter)
  counter.increment
  "%6d\t%s" % [counter.current, line]
end

This looks much better:

1
2
3
4
5
6
7
8
9
10
11
12

def numbered?(line)
  line_numbering_style  == :all_lines || significant?(line)

def significant?(line)
  line_numbering_style == :significant_lines && !blank?(line)

def blank?(line)
  line.nil? ? false : line.chomp.empty?

def numerize(line, counter)
  counter.increment
  "%6d\t%s" % [counter.current, line]

I am not talking about full blown Python indentation scheme.

Although it is working in haml just fine I hate counting spaces in the middle of method… I know this was talked about back in a day and the conclusion was that it’s not worthed. (I agree).

BUT I’ve noticed any time I write similar code in Clojure or Smalltalk I don’t get to write an end to the method. When I compare the results I always get the urge to write one liner in Ruby. It sort-of works for simple code (notice that there is no semicolon):

1

  def blank?(line) line.nil? ? false : line.chomp.empty? end

For anything bigger than that one liner makes it harder to read. For those cases when one liner is not cutting it I would even agree to put a dot at the end to ease things up for parser (if that helps):

1
2
3
4
5
6
7
8
9
10
11
12

  def numbered?(line)
    line_numbering_style  == :all_lines || significant?(line).

  def significant?(line)
    line_numbering_style == :significant_lines && !blank?(line).

  def blank?(line)
    line.nil? ? false : line.chomp.empty?.

  def numerize(line, counter)
    counter.increment
    "%6d\t%s" % [counter.current, line].

This is original implementation, great stuff from the Practicing Ruby.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

class Display
  def initialize(params)
    @line_numbering_style   = params[:line_numbering_style]
    @squeeze_extra_newlines = params[:squeeze_extra_newlines]
  end

  def render(data)
    @line_number = 1

    lines = data.lines
    loop { render_line(lines) }
  end

  private

  attr_reader :line_numbering_style, :squeeze_extra_newlines, :line_number

  def render_line(lines)
    current_line = lines.next
    current_line_is_blank = current_line.chomp.empty?

    case line_numbering_style
    when :all_lines
      print_labeled_line(current_line)
      increment_line_number
    when :significant_lines
      if current_line_is_blank
        print_unlabeled_line(current_line)
        # skip incrementing line number, want to only count significant lines
      else
        print_labeled_line(current_line)
        increment_line_number
      end
    else
      print_unlabeled_line(current_line)
      increment_line_number
    end

    if squeeze_extra_newlines && current_line_is_blank
       lines.next while lines.peek.chomp.empty?
    end
  end

  def print_labeled_line(line)
    print "#{line_number.to_s.rjust(6)}\t#{line}"
  end

  def print_unlabeled_line(line)
    print line
  end

  def increment_line_number
    @line_number += 1
  end
end

I’ve liked @JEG2 idea about not using loop and about trimming down render_line method a bit. I did not like the use of additional object that will carry state. This is what I’ve ended up with:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

module RCat
  class Display
    def initialize(params)
      @line_numbering_style   = params[:line_numbering_style]
      @squeeze_extra_newlines = params[:squeeze_extra_newlines]
    end

    def render(data)
      reset_line_number_counter

      data.reduce(false) do |previous_is_blank, line|
        next if squeeze_extra_newlines &&
                previous_is_blank && blank?(line)
        print format(line)
        blank?(line)
      end
    end

    private

    attr_reader :line_numbering_style,
                :squeeze_extra_newlines,
                :line_number

    def format(line)
      numbered?(line) ? numbered(line) : line
    end

    def numbered?(line)
      line_numbering_style  == :all_lines ||
      (line_numbering_style == :significant_lines && !blank?(line))
    end

    def blank?(line)
      line.chomp.empty?
    end

    def reset_line_number_counter
      @line_number = 0
    end

    def numbered(line)
      @line_number += 1
      "%6d\t%s" % [@line_number, line]
    end

  end
end

The code is so self explanatory :) that I don’t need to say anything except maybe that I am in reduce-happy-phase as visible from above.

Afterwards I’ve played a bit with removing that boolean logic from reduce and also with extracting the counter logic. This is the result:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

class Display
  def initialize(params)
    @line_numbering_style   = params[:line_numbering_style]
    @squeeze_extra_newlines = params[:squeeze_extra_newlines]
  end

  def render(data)
    counter = Counter.new

    data.reduce(nil) do |previous, current|
      next if squeeze_extra_newlines &&
              blank?(previous) && blank?(current)
      print numbered?(current) ? numerize(current, counter) : current
      current
    end
  end

  private

  attr_reader :line_numbering_style,
              :squeeze_extra_newlines,
              :line_number

  def numbered?(line)
    line_numbering_style  == :all_lines || significant?(line)
  end

  def significant?(line)
    line_numbering_style == :significant_lines && !blank?(line)
  end

  def blank?(line)
    line.nil? ? false : line.chomp.empty?
  end

  def numerize(line, counter)
    counter.increment
    "%6d\t%s" % [counter.current, line]
  end

end

class Counter
  attr_reader :current
  def initialize() @current  = 0 end
  def increment()  @current += 1 end
end

I like the last example the best because domain is really starting to show. I get to talk about being blank or significant etc… In theory .each_cons(2) seems to be better suited than .reduce for the job of “sliding” trough lines, but I am unable to make it work that way. (@ryanlecompte suggested it since I completely forgot about that method.)

Also it looks to me as if I need “Line” class that would have blank?, significant? and numbered? methods. Probably also “Configuration” class for line style. But that is something I would do if things begin to get complex, right now there is no need. I am pretty pleased on how the code is communicating what it is suppose to do.

Phase I - denial

You do notice that you are a bit different. Other people might even call you out for being a geek or nerd. You deny it and fight it.

Phase II - blending in

By now you acknowledge that you have a flaw. You try to compensate by doing “normal” stuff. In my case this included hiding/ignoring that I was interested in computers and alpha alcoholism instead of going to classes. I had a blast at high school and flunked a couple of years at college, but all in all I’ve sneaked trough.

Phase III - overcompensating

By now it starts to look as being a geek is not such a bad thing after all. As it turns out market demand for computer experts is high and you are doing cool stuff at work for a good paycheck. You even start calling yourself a geek.

We have all sort of geeks: all around geeks, geeks with hats, your favorite geeks… and yours truly geek from Croatia. Deep inside you still don’t want to be a geek from the phase I.

This is why we have all this jockey names for stuff:

• jQuery Ninja
• Coding Dojo
• eXtreme Programming
• Scrum

Looks like we are in effect overcompensating. It reminds me of this:

Conclusion

Where does this leaves us? I will stop calling myself a geek and if I ever contribute with anything I’ll give it a good honest name. Like Clojure or Ruby for example. No apologies, no warnings and no overcompensation.

I agree that:

Nightmare at 20,000 Feet via Wikipedia

I am going to bluntly ignore the details and just give the 20,000 feet look at it.

Block in Ruby is just another type of variable.

We all understand this:

1
2
3
4
5

def hello(name)
  puts "Hello #{name}."
end

hello "unfortunate reader" #=> Hello unfortunate reader.

We also understand that the functions in Ruby are a first class citizens; you can declare a function and save it for later usage like this:

1
2
3
4
5
6
7

function = ->(name){ puts "Hello #{name}." }  #defining for later execution

def hello(function, name)
  function.call(name)
end

hello function, "unfortunate reader" #=> Hello unfortunate reader.

It turns out block is just syntax sugar for that kind of variable.

Here is the deal: You don’t give a name to a function and it has to be the last argument. Let’s call it a block.

1
2
3
4
5

def hello(name, &block)
  block.call(name)
end

hello("unfortunate reader") {|name| puts "Hello #{name}." }  #=> Hello unfortunate reader.

This fact is somewhat shadowed with the use of implicit blocks and a special keyword yield. But don’t let that fool you. It is still just a (hidden) variable and being treated exactly the same as the above block.

1
2
3
4
5

def hello(name)
  yield(name)
end

hello("unfortunate reader") { |name| puts "Goodby #{name}." } #=> Goodby unfortunate reader.

The main complaint was that you need way too many lines of code for basic scenarios.

Similarly, after finding out about Ruby I was amazed that alpha geeks figured it out five years before me. When I think about it more carefully, it would not be logical any other way. I speculate that they were able to position Ruby as a Smalltalk derivate that has some Perl syntax sugar and some Lisp functional goodness. That enabled them to label/recognize the whole technology relatively fast and easy.

The previous knowledge of concepts was the main factor that enabled that.

The matter of fact is that very, very rarely we get a new concept that is also usable at the same time.

Concepts enable us to have a common vocabulary and to talk about problems more easily. They also transcendent the technology itself.

The matter of fact is that technology shelf life is 5-7 years. In that time something new will come along and evolve the state of the art. You have to ask yourself who are those people that are pushing the envelope. I think they are the one that are leaning on the shoulders of a giants from (glorious) past. They are able to look at technology instantly knowing its strong sides and limitations. I base this assumption on a fact that main factor in speeding up the whole human race progress was the invention of press machines. Books enabled people to share concepts on a much broader scale than before. Internet is in a way just improved and more interactive version of a book.

I bow my head to Lisp for giving as fold and map, I bow to Smalltalk for giving as block syntax and showing us how nice keyword arguments can really be. I bow my head to Unix for enabling us to connect programs the same way that we connect a garden hoses (standard input/output)…

Conclusion

Don’t just stand there, learn about traits from Smalltalk or about currying in (for example) Perl. That kind of knowledge is what is most important anyways.

Leave the APIs details in the documentation and look it up when needed.

In his article he questions (along with some other rules) the rule of never using regular expression for xml parsing.

As it turned out it was a fortunate move since six dollars and one day latter I came across .xml that needed to be parsed.

I have a confession to make: I’ve always hated xml parsers. This particular .xml did not even use xml strengths; data inside was all messed up:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

<?xml version="1.0" encoding="utf-8"?>
<rss version="2.0">
<channel>
<title>Exchage rates list</title>
<link>http://*******</link><description>Excange rates list 12/13/2011</description><item>
      <guid isPermaLink="false">code: 978</guid>
      <title>EMU (EUR)</title>
      <description>
          Unit: 1<br />
          Buying: 1.95583  <br />
          Medium: 1.95583  <br />
          Selling: 1.95583 <br />
      </description>

  </item>   <item>
      <guid isPermaLink="false">code: 36</guid>
      <title>Australia (AUD)</title>
      <description>
          Unit: 1<br />
          Buying: 1.488813<br />
      ...

In the article he made a good point and illuminated the edge cases where you are not really parsing, but rather just hunting for some data.

That was encouraging enough to end up with this:

1
2
3
4
5
6

data.gsub!("\n",'').gsub!("\t",'')
data =~ /Exchange rates list (\d+\/\d+\/\d+)/
  ...
data.scan /code:\s(\d+).*?\((\w+)\).*?Unit:\s(\d+).*?Buying:\s(\d+\.?\d+).*?Medium:\s(\d+\.?\d+).*?Selling:\s(\d+\.?\d+)/ do |item|
  ...
end

Does it feel good? It sure does. Is it any worse than using xml parser? No, I don’t think so. Data is safe and sound, just look how happy it looks:

1
2
3
4
5
6
7

"12/13/2011"
["978", "EUR", "1", "1.95583", "1.95583", "1.95583"]
["36", "AUD", "1", "1.488813", "1.492544", "1.496275"]
["124", "CAD", "1", "1.437051", "1.440653", "1.444255"]
["191", "HRK", "100", "26.021213", "26.086429", "26.151645"]
["203", "CZK", "1", "0.076274", "0.076465", "0.076656"]
...

Conclusion

I didn’t really break any rules. I just saw the whole problem more clearly because of his article. I figured I would need the regex anyhow since document was structured so unfortunately.

Other then recommending his articles I can say that being pragmatic can get you solutions that are on the other side of rules fence.

The thing is that sometimes the other side doesn’t have to be a bad side.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

w = %w[a c d b e] # same as w = ["a", "c", "d", "b", "e"]
w.sort #=> ["a", "b", "c", "d", "e"]
w.sort.reverse #=> ["e", "d", "c", "b", "a"]
w.sort { |a,b| b<=>a } #=> ["e", "d", "c", "b", "a"]

w.reduce(:+) #=> "acdbe"
w.map(&:upcase) #=> ["A", "C", "D", "B", "E"]

w.include? "a" #=> true

(1..8).select(&:even?) #=> [2, 4, 6, 8]
(1..8).reject(&:even?) #=> [1, 3, 5, 7]

langs = %w[ruby python perl] # same as langs = ["ruby", "python", "perl"]

langs.group_by(&:chr) #=> {"r"=>["ruby"], "p"=>["python", "perl"]}
langs.map(&:capitalize) #=> ["Ruby", "Python", "Perl"]

As they say:

The beauty of Ruby is found in its balance between simplicity and power.

If after this your mouth is watering, you can try Ruby online.

When I test I know my system works. I sleep like a baby. I have a balls of brass. I can embrace change and laugh at how easy it is to add new requirements.

The thing is, in my life I’ve seen a fair amount of big systems that are terrible. They all have one thing in common. Everybody hates them. Programmers, users… but they do work, sort of. They are slow and buggy but nevertheless they deliver some value to the users.

Enterprise is euphemism for lame systems that barely work for 300 users?

Oddly, in many of those terrible systems funny thing happened. After a while guess what? People involved (users and programmers) made those terrible systems work (just enough) and all of a sudden you have a winner. Bigger the system, bigger the win. Bigger the mess, bigger the ecosystem of additional companies making it all work.

Think Windows & antivirus for example.

I wonder how smug IBM felt when developing OS/2 with all the cool stuff…and than a big nothing happened. Right now you might be thinking that I’ve lost it. You are ready to click away… but let see some examples:

World War II Tiger vs. T-34

One of the most advanced features of the Tiger was its assembly process. Flat section armour plate was used throughout the assembly process, which allowed the use of heavy armour. Various parts were made as one complete unit complete with interlocking joints that made assembly a quick process. Rings a bell? They where too heavy for most bridges, but it was not problem since they’ve added snorkel?! (later abandoned). However it costed staggering 250,000 marks. Meanwhile Russians had a pile of crap. One Tiger could easily destroy multiple Russians cans. There is one minor detail; at the end of the war Russians manufactured 1.300 T-34 monthly and Germans managed to produce 1.500 Tigers all together. It was not a coincidence it was a trade off. Did quality matter? It did, but not all that much for the bottom line.

Some other factors were more important than mere quality.

They were able to match Tiger quality later on while winning the whole time. By the end of the war, other tanks had been developed that outclassed the Tiger based on the lessons learnt on low quality mass production which also secured the front.

Bradley Fighting Vehicle

Development started at 1964 and since then project requirements changed a couple of times (big changes)… I don’t know if “Pentagon Wars” have any truth in it, but it does look a lot like a massive project gone awry. They’ve pulled it of just on muscle power and hard-as-opposite-to-smart work. The only guy that insisted on quality was force-retired (Coloner Burton). Eventually 17 years and 40 billion dollars later they’ve managed to slap together product that is in use even today. After a few additional iterations based on combat experience it even became good enough. Prototype that will replace Bradley is planned for 2015. In software project terms this is considered a success. Did it matter that quality suffered most of the time? No, not really.

Elevator

I sometimes ride a buggy elevator near where I live. You need to press “floor 3” the display shows “floor 2” and you actually go to “floor 1”. Am I unhappy? Am I not using it? The thing is I don’t care and it doesn’t stop me from riding it. When someone new is with me I even get to crack jokes about it. All in all it is a complete win despite obvious flaws.

Conclusion

I will not stop to test drive my code. I like the immediate feedback and the power I get from knowing that system is working. I like evolving the code in an organic manner. I like to garden and polish code. This post is acknowledgment that the other side has it’s strong points. It is not luck that they also make their way work. You can balance your trade-offs in a different constellation and if you are smart enough you may be in equal or even better position. It is not quality that matters, but being a champion.

Champions are underrated because of industry obsession with silver bullets. Throw any technology at champions and give them a goal. Being a champion is much more important than anything else. It is a known fact that OOP projects had much better success rate than procedural paradigm at the beginning of OOP wave. Reason was that you had all the champions trying out this new cool stuff. After a while the numbers evened up back to the average.

It just happens that today rage is all about Ruby, Clojure and what not. That means that you have a bunch of champions piled up. I bet all of those guys would pull it off in any technology and with any development technique.

Quick warning: If you don’t like monkey patching… Run away now it is still not too late…

1
2
3
4
5
6
7
8
9
10
11
12

# Copied from
# http://blog.teksol.info/2007/11/23/a-little-smalltalk-in-ruby-if_nil-and-if_not_nil
# http://recursive.ca/hutch/2007/11/22/a-little-unnecessary-smalltalk-envy/
# Bob Huntchison
# Shortened to just support if_not_nil
class Object
  def if_not_nil(&block) yield(self) if block end
end

class NilClass
  def if_not_nil(&block) end
end

This enables you to stop treating nil as a special case:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

class Person
  attr_reader :name
  def initialize(name)
    @name = name
  end
end

def person_that_exists
  Person.new("drKreso")
end

def non_existing_person
  nil
end

person_that_exists.if_not_nil { |person| puts "found #{person.name}"} # => found drKreso
non_existing_person.if_not_nil { |person| puts "found #{person.name}"} # => nothing happens

This is easy enough to comprehend. We enabled NilClass to respond to if_not_nil by doing nothing. Normal object reacts on the same message by injecting self to the block and having wanted side effects. Is it useful? I don’t know but I think it’s cute.

Yesterday I saw this taken a step further in the example that is (I think) created for the new book Objects on Rails whose beta I’ve read and highly recommend. Original is available at Avdi Grimm gist example.

The cool part is this short but sweet addition to Object (I told you about monkey patching right?)

1
2
3
4
5

class Object
  def when(matcher)
    if matcher === self then yield(self) else self end
  end
end

Now you don’t have special cases for if_nil or if_not_nil. Actually you can stick in any lambda you want (or so I thought). When the condition is satisfied you get to execute the block with self injected in it. Otherwise you get a no go!

1
2

person_that_exists.when(->(p){ !p.nil? }) { |p| puts "found #{p.name}"} #=> found drKreso
non_existing_person.when(nil) { puts "Nothing, move along"} #=> Nothing, move along

And now here is the part(finally) that blew my mind. Since you need to put in Proc and Proc#=== is defined as : “Invokes the block with obj as the proc’s parameter like Proc#call.”
This question arises: How come I am not able to rewrite the when definition with Proc#call? It just doesn’t add up… This was the most explicit version that I could write that (I speculated) does the same thing:

1
2
3

def when(matcher, &block)
  if (matcher.nil? || matcher.call(self)) then block.call(self) else self end
end

I read it like this: If matcher is nil or if calling the matcher lambda/proc gives me true then inject self into the block. Otherwise just pass self. Now this was problematic because I had to deal with special case when matcher was nil. Otherwise I could not get it to work… yet #=== worked just fine.

The answer turned out pretty simple (Thanks @avdi)

It does not have to be lambda(proc) it can be anything that has #=== defined and that would be well anything derived from Object and that would be: everything. (I am not going to dwell about BasicObject here.) So it turns out that Proc happens to invoke call for #=== which is rather fortunate.OH: now it all makes sense, and I fell a bit well you know…

Since NilClass does not have a #=== defined and since it is derived from Object it ends up calling Object#=== that turns to call Object#==. Inheritance in its full glory, you get to use anything you want for a matcher. End of story.

Conclusion

If you ignore my unnecessary wanderings this is pretty neat technique. I am sorry I skimmed the sections about Case Equality (===) in all the books I’ve read since it turned out pretty useful. That with combination of me obsessing that it has to be lambda blew my mind pretty well so I thought this might help someone.

Lessons learnt

• I had a reason to do it since I was unable to find part of Christmas decorations
• I managed to “forget” that I had duplication. (Two Christmas trees for example, two saws, countless other smaller things). Important thing is that I am (legally) sane. So I figure this forgetfulness is normal.
• There was a lot of junk that I didn’t need
  • I threw out lot of the junk
  • I did not throw out everything, although I was tempted
• Some of the junk was really heavy to carry and garbage container was far away
• Some of the stuff was borderline and I could not decide whether to throw it out or not
• It was beneficial to separate junk on one pile and throw it all out at once
• For I while I was in a hole and literally could not get out
• I’ve needed a lot of space while in the process
• There was a glass on the floor, so I was at risk to get cut on it the whole time
  • I never got cut before
  • I got cut when I tried to clean it up
• After I was done
  • It was not perfect
  • It was better than before
  • I’ve had a much better understanding of what was inside

Conclusion

I was amazed at how little I knew about the content I’ve found. Even if I vaguely knew I had something I was unable to locate it. For lots of stuff I was just amazed that I even have it.

After all the hard work decorations were retrieved and the basement was better than before.

I guess refactoring has a lot more in common with cleaning a basement than I thought it would.

In Smalltalk it would be used like this:

1
2
3

(1 = 1)
    ifCorrect:    [Transcript show: 'I am correct']
    ifNotCorrect: [Transcript show: 'I am wrong'].

My knowledge of Smalltalk is non-existing, but look at the beautiful [] block syntax and notice the keyword arguments being able to accept multiple blocks.

Implementation in Smalltalk is both straightforward and cool:

1
2
3
4
5
6
7

# this is in True class
ifCorrect: trueAlternativeBlock ifNotCorrect: falseAlternativeBlock
     ^trueAlternativeBlock value

# this is in False class
ifCorrect: trueAlternativeBlock ifNotCorrect: falseAlternativeBlock
     ^falseAlternativeBlock value

In Ruby I was missing the ability to have multiple blocks in method call that would enable me to evaluate only one leg. This was best I could come up with and it included (mis)using the lambdas:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

class FalseClass
  def if_correct(trueBlock, hash)
    hash[:if_not_correct].call
  end
end

class TrueClass
  def if_correct(trueBlock, hash)
    trueBlock.call
  end
end

(1==0).if_correct ->{ print "Hooray it's true"},
       if_not_correct:->{print "Not true"}

Today I’ve read the excellent post about using Ruby Blocks as Dynamic Callbacks. I was mesmerized, but of course I didn’t get it. Than I saw really kick ass explanation here. Holding hands did have effect even on me. Still I am not sure that I would be able to pull it of on my own without watching the original code. At the end I did saw one gist in comments claiming to have similar pattern. I don’t know if it’s better, but it looks less intrusive because there is no patching of Proc class and it clicked more easily.

As an exercise I’ve decided to use technique described there to implement my version of if..else:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

#1
Custom.if(1 == 0) do |condition|
  condition.true? do
    puts "True"
  end.false? do
    puts "False"
  end
end

#2
Custom.if(1 == 0) do |condition|
  condition.true? { puts "True" }.
  false? { puts "False" }
end

#3 (my favourite)
Custom.if(1 == 0) do |condition|
  condition.true? { puts "True" }
  condition.false? { puts "False" }
end
...

It’s relatively easy to explain how it works. Look at the definition of Custom class:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

class Custom
  def self.if(condition, &block)
    proxy = BlockProxy[block]
    if condition
      proxy.call_block_for :true?
    else
      proxy.call_block_for :false?
    end
  end

  class BlockProxy
    def self.[](block)
      new.tap { |proxy| block.call(proxy) }
    end

    def call_block_for(callback, *args)
      callbacks[callback].call(*args)
    end

    def method_missing(m, *args, &block)
      block ? callbacks[m] = block : super
      self
    end

    def callbacks
      @callbacks ||= {}
    end
  end
end

line 2 : Using self.if method that receives condition and the block

1
2
3
4
5
6
7

codition ==> (1 == 0) ==> false
block  ==>
  condition.true? do
    puts "True"
  end.false? do
    puts "False"
  end

• line 3 : Creating the BlockProxy that is responding to missing method call in a way to:
  • If there is passed in block then store it under method name in @callbacks variable
  • If there is no passed block then raise the classic no method found exception

If you now look at usage of Custom class

1
2
3
4
5
6
7

Custom.if(1 == 0) do |condition|
  condition.true? do
    puts "True"
  end.false? do
    puts "False"
  end
end

notice that |condition| is really a BlockProxy object that you’ve tapped in on line 13.
So when you call:

1

condition.true?

you invoke method_missing on a BlockProxy that stores received block in @callbacks hash with :true? key:

1
2

#stored block under :true? key
puts "True"

It’s all great from there on. Next call to false? invokes method_missing again and stores passed in block under :false? key:

1
2

#stored block under :false? key
puts "False"

When all of this is set and done I get to implement my version of if..else with built in if..else (line 4..8 in Custom class) :)

Conclusion

The thing is that with this technique I can do whatever I want with my version of if..else. I may alter it to log something when condition is true or do something similarly outrageous. Also it looks as if I could easily implement switch…case idiom etc. Is it practical to replace existing syntax? I don’t think so, but it really is intriguing and I am glad that it can be pulled of in Ruby like this. I want to thank Matt Sears, @bodhi and Ryan LeCompte for taking this one off of my chest.

This technique does give you yet another tool for creating pure Ruby DSL-s.

The decorator pattern is used to extend the functionality of a certain object in a runtime. In a statically typed language you need to define decorator interface, then subclass from it and initialize the component (object) that you are decorating.

In Ruby you can pledge: “Yes I am a grownup” and skip the formal interface definition part.

In either case the payoff comes with the fact that you can combine “extensions” without writing out complex inheritance tree that accounts for all possible combinations. Therefore you end up using extension that you need when you need them.

Let’s check it out on Wikipedia coffee example.

1
2
3
4
5
6
7
8

class Coffee
  def cost
    1
  end
  def ingredients
    %w(coffee water sugar)
  end
end

If we want some latte, we can create a new decorator for the coffee:

1
2
3
4
5
6
7
8
9
10
11

class Latte
  def initialize(component)
    @component = component
  end
  def cost
    @component.cost * 1.2
  end
  def ingredients
    @component.ingredients << "milk" << "whipped cream" << "vanilla"
  end
end

We can now have some latte:

1
2
3

latte_coffee = Latte.new(Coffee.new)
pp latte_coffee.ingredients ==> ["coffee", "water", "sugar", "milk", "whipped cream", "vanilla"]
pp latte_coffee.cost ==> 1.2

You only need to implement methods that are extending the base methods. For double coffee we need to implement cost, but the ingredients method is just delegating to the decorated class:

1
2
3
4
5
6
7
8
9
10
11

class DoubleCoffee
  def initialize(component)
    @component = component
  end
  def cost
    @component.cost * 2
  end
  def ingredients
    @component.ingredients
  end
end

Instead of accounting for all cases with inheritance (upfront aka tedious): You can plug it in decorator pattern that looks something like this:

This is small example but I hope that the full scale of combination explosions problem that would occur in bigger scenarios is visible.

Ruby has a cool solution for delegation blues (writing boilerplate code to wrap up unchanged delegated methods). On the example below you are arguably at lost for using forwardable, but the more methods you need to delegate better of you are with forwardable.

1
2
3
4
5
6
7
8
9
10

class DoubleCoffee
  extend Forwardable
  def_delegator :@component, :ingredients
  def initialize(component)
    @component = component
  end
  def cost
    @component.cost * 2
  end
end

If you have really big number of methods and you don’t need to be too selective about what you are delegating then you can pull out the big guns and implement some method_missing magic.

To digress a bit I thought that method_missing is the best thing since sliced bread and also really original idea. That was until I’ve met doesNotUnderstand message in Smalltalk. Then I felt humbled for a while… Man they had it back than and still it was new to me even today.

To get back on the decorator. You can be explicit about what’s going on:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

class CoffeeDecorator
  extend Forwardable
  def initialize(component)
    @component = component
  end
end

class DoubleCoffee < CoffeeDecorator
  def_delegator :@component, :ingredients
  def cost
    @component.cost * 2
  end
end

class Latte < CoffeeDecorator
  def cost
    @component.cost * 1.2
  end
  def ingredients
    @component.ingredients << "milk" << "whipped cream" << "vanilla"
  end
end

Punchline is that decorators enable you to chain the functionality that you need the way you need it without spelling it out in inheritance tree:

1
2

latte = Latte.new(Coffee.new)
double_coffee_with_latte = DoubleCoffee.new(latte)

Ruby modules

You can create the same effect by using modules. It looks rather sexy:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

module DoubleCoffee
  def cost
    cost * 2
  end
end

module Latte
  def cost
   super * 1.2
  end
  def ingredients
    super << "milk" << "whipped cream" << "vanilla"
  end
end

c = Coffee.new
c.extend Latte
c.extend DoubleCoffee

In practice you would probably build some kind of factory to ease the pain of all this flexibility for the client:

1
2
3
4
5

class CoffeeFactory
  def self.double_coffee_with_latte
   return Coffee.new.extend(DoubleCoffee).extend(Latte)
  end
end

One gotcha is that you need to watch out for you methods to be truly chainable. For example if we had:

1
2
3
4
5
6
7
8

module Latte
  def cost
    super + 0.5
  end
  def ingredients
    super << "milk" << "whipped cream" << "vanilla"
  end
end

We would not get the same cost for:

1
2

   Coffee.new.extend(DoubleCoffee).extend(Latte).cost ==> 2.5
   Coffee.new.extend(Latte).extend(DoubleCoffee).cost ==> 3

Methods wrapping

One more alternative is to wrap up methods in runtime. For example you can implement DoubleCoffee decoration like this:

1
2
3
4
5
6
7

c = Coffee.new
class << c
  alias old_cost cost
  def cost
    old_cost * 2
  end
end

Rails has a real nice variation of this tehnique with their alias_method_chain method.

Conclusion

I think this is one of those patterns that looks really good in theory. And as they say, “in theory, theory and practice are the same”. I would say that in practice you need to carefully judge wether the flexibility gained is worthed increased complexity for the client code. Nevertheless it is nice to know that Ruby is offering some refreshing ways to do it if you really need to.

I am not a power user by far but I do have some favorite tricks.

Using console version

• Pros:
  • Console output is colored
  • Ctrl-y puts you to console, fg puts you right back
  • No need to open console in another window
• Cons:
  • Color scheme is a bit uglier (less color in console)
  • Copy paste is a bit harder (from other GNOME apps, at least for me)

I’ve tried everything here. Rationally I thought that the console version is too ugly. BUT I noticed that I type vim from terminal unconsciously. The Ctr-y/fg combo and ability to start test to console from within vim sealed the deal. Somehow I got use to lack of prettier color scheme.

Running tests from vim

1

map ,t :w\|!rspec spec %<cr>

This combined with sub-second testing is really nice.

While on the subject, when doing one time scripts this is rather fast way to run script:

1

map ,r :w\|!ruby %<cr>

You are always ,r away from the results.

Using Command-T plugin

Much better than fuzzy finder. I am not even going to talk about “tree” explorers of any kind. Command-T is really really great. If you haven’t I urge you to try it out right now.

One gotcha is that if I create a new file I need to refresh my Command-T index, and CommandTFlush is just the right way to do it

1

map ,f :CommandTFlush<cr>

Using $MYVIMRC global

When tweaking .vimrc configuration file I can use $MYVIMRC global. It’s customary that you want your changes to take effect immediately

1

:so %

Using % for current file

When running tests I usually map to the spec I am working on. It’s not as much work as you would think and it enables you to run tests from wherever. Still sometimes it is nice to reference “current” file and % is a way to do it.

Yank the line without moving cursor

This one is super simple yet it eluded me for quite some time. For example if I am on line 40 and want to copy the content of line 28

1

:28y

Than ESC and p to put it. Talking about ESC I did try to switch ESC with CAPSLOCK. Didn’t find it particularly cool.

Switch between buffers

1

Ctrl-6 

Toogle buffers

1

:A

Alternate file (rails.vim to switch between spec and working class and some other combinations)

Rails

rails.vim of course Tim Pope is a true hero for this. (Also fugitive.vim is nice wrapper for git, but having easy access to the console lessens the need for that plugin.)

Theming

I like the desert theme. Also yesterday I saw a cool terminal emulator secret geometry. They basically disregarded the last 20 years of progress in screen technology.

Conclusion

That pretty much wraps everything I had in mind. I admit that you need some love for console version and vim in general. But I feel you get payoff relatively fast.

If you know what test doubles are. If you know that stub gives canned answers and that mock is an object that you can set expectations on… Pass along. If you are still uncertain about this you may want to read on.

Stubs

Chances are (if you are a guy) that you are using stub when talking to your girlfriend:

Does my ass look big in this jeans? No!

It doesn’t matter what the real answer is, you just give back the prepared one. Kinda like when you need certain data for your tests. You shove in your answer for example 11/28/2011 and you expect the canned answer every time. It’s a lie agreed upon for the greater cause.

Mocks

Mock is emotionally ‘complicated’ stub. He also gives back canned answers but he expects certain things to be done in the process to be fully satisfied. Translated to our girlfriend example it is something like this:

Are you cheating on me? No!

Here the expectation is that you don’t give answer right away, because it looks canned that way. Also you shouldn’t think to long before answering. Mocked object v2.0 might expect that you look her in the eyes…

DRY me is noticing that we have overlapping in code, so I would probably use the same algorithm for both question in the class BlowTheTruthOutOfWaterIfItsBrutal.

Why Would I Mock/Stub Anyway

1. You don’t have the collaborator object when TDD-ing feature
2. Collaborator is slow
3. Collaborator is ‘outside’ component
4. You want to isolate your tests more
5. You want canned answers (time travel for example)

Caveat

You have a green tests and non working application when stub/mock is not mimicking the real collaborator good enough. It makes you look pretty stupid, so watch out for this!

1. JIRA is down
2. JIRA is slow (I am complicated about speed, kinda like Corey Haines)

In order to mitigate that, I’ve started writing notes to .txt file. I would then type-in all hours at the end of the day. It’s just me and my beloved Vim. What could go wrong? Right?

Well, it sounded better in theory as it had its own share of problems, such as:

1. Keeping the file open all day long (and more so finding it)
2. Forcing myself to fiddle with JIRA for x tasks (not to mention “at the end of the day” part)

Command Line To The Rescue

At the end I’ve settled with using command line for logging work to intermediate “send” file (instantaneous) and than at the end of the day sending the whole batch to JIRA via API.

1
2
3
4
5
6

rake log:work[1,1h,'Really ground breaking work']
rake log:work[1,2h,'Best thing since sliced bread']
rake log:work[1,3h,'Finding missing semicolon']
rake log:work[OTHERPROJ-1,2h,'Figuring out how to send parms via Rake :)']

rake log:send

Rake is a bit moody as interface. You need to watch out not to use comma except as a token delimiter. (For example I didn’t find the way to use it in comment). And it’s super sensitive to spaces so I tend not to write them.

My language of choice was Ruby, and for interface I’ve used Rake. Mostly because that way I can add recurring tasks to rake (such as holidays…) and I can list all my tasks for free with:

1

rake -D

The code is not all that important as I had much more trouble finding the optimal workflow. Nevertheless I’ll put the code below in hope that someone will find it useful:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

require 'yaml'

class LogWork
  class << self
    SendList = "send_list.yaml"

    def add_work(task_key, time_spent, comment, go_back_in_days = 0)
      list = send_list
      list <<  [task_key, time_spent, comment, go_back_in_days]
      save(list)
    end

    def send_all(target)
      sent, list = [], send_list
      list.each { |task| sent << task if target.add_work(task[0], task[1], task[2], task[3]) }
      save(list - sent)
    end

    def send_list() File.exists?(SendList) ? File.open(SendList, "r") { |file| YAML.load(file) } : [] end
    def save(list) File.open(SendList, "w") {|file| file.puts(list.to_yaml) } end
    def reset() File.delete(SendList) if File.exists?(SendList) end
  end
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

require 'rake'
require_relative 'log_work'
require_relative 'jira'

namespace :log do
  desc 'Add worklog to JIRA'
  task :work, [:task_key, :time_spent, :comment, :go_back_in_days] do |t, args|
    args.with_defaults(:go_back_in_days => 0)
    task_key = args[:task_key]
    task_key = task_key.to_i if task_key =~ /^[0-9]+$/
    LogWork.add_work(task_key, args[:time_spent], args[:comment], args[:go_back_in_days].to_i)
  end

  desc 'Send all worklogs to JIRA'
  task :send do
    LogWork.send_all(Jira)
  end
end

Talking to JIRA is done via Savon:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

require 'jiraSOAP'
require 'savon'

Savon.configure do |config|
  config.log = false
  config.log_level = :info
end

class Jira

  ServiceURI = #you_jira_address
  ServiceWSDL = "#{ServiceURI}/rpc/soap/jirasoapservice-v2?wsdl"
  UserName = #your_user_name
  Password = #your_password
  DefaultProject = #your_default_project

  def self.add_work(task_key, time_spent, comment, go_back_in_days = 0)
     task_key = "#{DefaultProject}-#{task_key}" unless task_key.to_s.upcase =~ /^[A-Z]+-[0-9]+$/
     go_back_in_days = go_back_in_days.to_i
     result = false
     begin
       db = JIRA::JIRAService.new ServiceURI
       db.login UserName, Password
       client = Savon::Client.new ServiceWSDL
       response = client.request 'addWorklogAndRetainRemainingEstimate'  do
         soap.body = {
           :in0 => db.auth_token,
           :in1 => task_key,
           :in2 =>  { :timeSpent => time_spent, :comment => comment , :startDate => DateTime.now - go_back_in_days }
         }
       end
       result = true
     rescue
       print $!
       result = false
     end
     return result
   end

end

String method downcase is local insensitive, meaning it ignores UTF-8 characters not in standard ASCII character set.

Example below will give you expected results:

1
2
3

"HELLO”.downcase 

-->hello

Next example will not behave as desired as non standard characters remain in uppercase:

1
2
3

"DINING ROOM - SALLE À MANGER".downcase

-->dining room - salle À manger

It is supposed to be fixed in Ruby 2.0. Until then you’ll need some monkey patching:

1

gem install unicode

1
2
3
4
5
6
7
8
9

#enviroment.rb
require 'unicode'
require 'lib/string'
#lib/string.rb
class String
  def downcase
    Unicode::downcase(self)
  end
end

Risky business, I know. But it’s the only only solution that I know of.