Daniel P. Clark | 6ft Dan™ “Sound Software Design”

May 29, 2016 by Daniel P. Clark

How to Build the Ultimate Remote Pair Programming Environment

There are a handful of desktop sharing apps out there and there are plenty of shell/editor sharing setups. But the biggest problem with these is you are opening up your own personal computer to not only the person(s) you’re connecting with, but also the potentially vulnerable or malicious technology you choose to use. A proper…

April 21, 2016 by Daniel P. Clark

Encrypted Linux Backup with Google Drive and Duplicity

When it comes to protecting your important data it’s best to have at least 3 copies of your things backed up. One should be air-gapped (not actively connected) and another be offsite (not at the same building). The air gap will protect against malicious code that would encrypt all your files and force you to…

April 21, 2016 by Daniel P. Clark

Use Ruby’s Refinements Anywhere With An Anonymous Class

For a long time I’ve been looking for a way to use Ruby’s refinements without building a class & method setup and then instantiating an instance of the class just to use it. And now I’ve finally found a solution.


module Moo
  refine Fixnum do
    def to_s
      "moo"
    end
  end
end

# begin/end blocks allow access to local variables
begin # valid Ruby 2.2.3 and NOT Ruby 2.3.0
  using Moo
  1.to_s
end
# => "moo"

# class syntax has no access to outer local variables
class << Class.new # valid Ruby 2.3.0
  using Moo
  1.to_s
end
# => "moo"

module Moo

refine Fixnum do

def to_s

"moo"

end

# begin/end blocks allow access to local variables

begin # valid Ruby 2.2.3 and NOT Ruby 2.3.0

using Moo

1.to_s

end

# => "moo"

# class syntax has no access to outer local variables

class << Class.new # valid Ruby 2.3.0

using Moo

1.to_s

end

# => "moo"

The best work around I’ve found for accessing values outside the class wood be…

March 22, 2016 by Daniel P. Clark

Rails: Has One Through Polymorphic Relation

As I’ve described in my blog post “Rails Polymorphic Associations” I’ve stated that polymorphic relations in Rails are best for scenarios where a model may “belong to” one of many other kinds of model. So a Comment model with the polymorphic commentable relationship can belong to any other record in your Rails app. This is…

March 7, 2016 by Daniel P. Clark

Make the Impossible Possible

[Don’t Listen to the Naysayers.] How many times have you heard that you can’t do this and you can’t do that and it’s never been done before? I love it when someone says that no one has ever done this before, because then when I do it that means that I’m the first one that has…

February 2, 2016 by Daniel P. Clark

Ruby: Bindings Across Inheritance

One thing you will find yourself needing to do is work across different scopes and in different ways. I would like to show one way of modifying local variables by passing a Binding object. Let’s say you’re going to write encryption classes and you’ll have different ways of encrypting and decrypting. For these you will have…

January 13, 2016 by Daniel P. Clark

101 Ruby Code Factoids

0) ‘methods’ method Since almost everything in Ruby is an Object you can type dot methods on it to see what methods are available.


4.methods - Object.methods
# => [:-@, :+, :-, :*, :/, :div, :%, :modulo, :divmod, :fdiv, :**, :abs, :magnitude, :~, :&, :|, :^, :[], :<<, :>>, :to_f, :size, :bit_length, :zero?, :odd?, :even?, :succ, :integer?, :upto, :downto, :times, :next, :pred, :chr, :ord, :to_i, :to_int, :floor, :ceil, :truncate, :round, :gcd, :lcm, :gcdlcm, :numerator, :denominator, :to_r, :rationalize, :singleton_method_added, :coerce, :i, :+@, :remainder, :real?, :nonzero?, :step, :quo, :to_c, :real, :imaginary, :imag, :abs2, :arg, :angle, :phase, :rectangular, :rect, :polar, :conjugate, :conj, :between?]

4.methods - Object.methods

# => [:[email protected], :+, :-, :*, :/, :div, :%, :modulo, :divmod, :fdiv, :**, :abs, :magnitude, :~, :&, :|, :^, :[], :<<, :>>, :to_f, :size, :bit_length, :zero?, :odd?, :even?, :succ, :integer?, :upto, :downto, :times, :next, :pred, :chr, :ord, :to_i, :to_int, :floor, :ceil, :truncate, :round, :gcd, :lcm, :gcdlcm, :numerator, :denominator, :to_r, :rationalize, :singleton_method_added, :coerce, :i, :[email protected], :remainder, :real?, :nonzero?, :step, :quo, :to_c, :real, :imaginary, :imag, :abs2, :arg, :angle, :phase, :rectangular, :rect, :polar, :conjugate, :conj, :between?]

1) _ In IRB the use of the underscore variable _ will hold the evaluation of the last line of code executed. When the variable is used in code it’s…

December 12, 2015 by Daniel P. Clark

Ruby: Arrays by Example

Arrays are Ruby’s most used collection type. I will use very little description as I give examples for the many different ways to work with Arrays. Different ways to create an empty Array


[]
Array.new
Array[] # same as :new
Array(nil) # tries converting to an Array first and insures an Array result

%w^^ # you can use any character pair-up after the w.  content won't need quotes
%W^^ # Allows string interpolation

[]

Array.new

Array[] # same as :new

Array(nil) # tries converting to an Array first and insures an Array result

%w^^ # you can use any character pair-up after the w. content won't need quotes

%W^^ # Allows string interpolation

Filling an Array


laughing_pirate = Array.new(3, :arr)
# => [:arr, :arr, :arr]

[42] * 5
# => [42, 42, 42, 42, 42]

[1,2,3].insert(10,8) # position, item ## fills beyond with nil
# => [1, 2, 3, nil, nil, nil, nil, nil, nil, nil, 8]

x = [1,2,3]
x[9] = 10 # just like insert
# => [1, 2, 3, nil, nil, nil, nil, nil, nil, 10]

laughing_pirate = Array.new(3, :arr)

# => [:arr, :arr, :arr]

[42] * 5

# => [42, 42, 42, 42, 42]

[1,2,3].insert(10,8) # position, item ## fills beyond with nil

# => [1, 2, 3, nil, nil, nil, nil, nil, nil, nil, 8]

x = [1,2,3]

x[9] = 10 # just like insert

# => [1, 2, 3, nil, nil, nil, nil, nil, nil, 10]

Insertion


[1,2,3,4,5,6].insert 4, :hello
# => [1, 2, 3, 4, :hello, 5, 6]

x = [1,2,3,4,5,6,7,8]
x[2,4] = :hello # slice replacement
x
# => [1, 2, :hello, 7, 8]

x[2,2] = [3,4,5,6] # slice replacement
x
# => [1, 2, 3, 4, 5, 6, 8]

x[2] = [8,7] # creates inner array
x
# => [1, 2, [8, 7], 4, 5, 6, 8]

x[1..4] = [7] # range slice insertion
x
# => [1, 7, 6, 8]

[1,2,3,4,5,6].insert 4, :hello

# => [1, 2, 3, 4, :hello, 5, 6]

x = [1,2,3,4,5,6,7,8]

x[2,4] = :hello # slice replacement

# => [1, 2, :hello, 7, 8]

x[2,2] = [3,4,5,6] # slice replacement

# => [1, 2, 3, 4, 5, 6, 8]

x[2] = [8,7] # creates inner array

# => [1, 2, [8, 7], 4, 5, 6, 8]

x[1..4] = [7] # range slice insertion

# => [1, 7, 6, 8]

Boolean/Truthiness


[false, false, false].all?
# => false 

[true, false, false].all?
# => false 

[true, true, true].all?
# => true

[false, false, false].any?
# => false 

[false, true, false].any?
# => true

[1,2,3,4].all?(&:even?)
# => false

[1,2,3,4].any?(&:even?)
# => true

[1,2,3,4].any? {|item| item > 2 && item < 4}
# => true

[1,2,3,4].one?
# => false 

[4].one?
# => true

[1,2,3,4].one?(&:even?)
# => false

[1,2,3].one?(&:even?)
# => true

[1,2,3].empty?
# => false 

[].empty?
# => true

[1,2,3].include? 5
# => false

[1,2,3].frozen?
# => false

[1,2,3].eql? [1,2]
# => false

[1,2,3].== [1,2]
# => false

[false, false, false].all?

# => false

[true, false, false].all?

# => false

[true, true, true].all?

# => true

[false, false, false].any?

# => false

[false, true, false].any?

# => true

[1,2,3,4].all?(&:even?)

# => false

[1,2,3,4].any?(&:even?)

# => true

[1,2,3,4].any? {|item| item > 2 && item < 4}

# => true

[1,2,3,4].one?

# => false

[4].one?

# => true

[1,2,3,4].one?(&:even?)

# => false

[1,2,3].one?(&:even?)

# => true

[1,2,3].empty?

# => false

[].empty?

# => true

[1,2,3].include? 5

# => false

[1,2,3].frozen?

# => false

[1,2,3].eql? [1,2]

# => false

[1,2,3].== [1,2]

# => false

Transformations


# zip
['H', 'l', 'o', 'o', 'l'].zip( ['e', 'l', 'W', 'r', 'd'] )
# => [["H", "e"], ["l", "l"], ["o", "W"], ["o", "r"], ["l", "d"]]

# transpose
[["H", "e"], ["l", "l"], ["o", "W"], ["o", "r"], ["l", "d"]].transpose
# => [["H", "l", "o", "o", "l"], ["e", "l", "W", "r", "d"]]

# product
[:a,:b,:c].product [1,2,3]
# => [[:a, 1], [:a, 2], [:a, 3], [:b, 1], [:b, 2], [:b, 3], [:c, 1], [:c, 2], [:c, 3]]

# combination (no repetitions of pairings)
[:a,:b,:c,:d].combination(2).to_a
# => [[:a, :b], [:a, :c], [:a, :d], [:b, :c], [:b, :d], [:c, :d]]

# permutation (will give both [a,b] and [b,a])
[:a,:b,:c].permutation(2).to_a
# => [[:a, :b], [:a, :c], [:b, :a], [:b, :c], [:c, :a], [:c, :b]]

# reverse and reverse!
[1,2,3].reverse
# => [3, 2, 1]

# sort and sort!
[2,1,3].sort
# => [1, 2, 3]

# shuffle and shuffle!
[1,2,3].shuffle
# => [3, 1, 2]

# uniq and uniq!
[2,1,3,3,1,2].uniq
# => [2, 1, 3]

# rotate and rotate!
[:a,:b,:c].rotate
# => [:b, :c, :a]

# compact and compact!
[:a,:b,nil,nil,nil,:c].compact
# => [:a, :b, :c]

# flatten and flatten!
[["H", "e"], ["l", "l"], ["o", "W"], ["o", "r"], ["l", "d"]].flatten
# => ["H", "e", "l", "l", "o", "W", "o", "r", "l", "d"]

# zip

['H', 'l', 'o', 'o', 'l'].zip( ['e', 'l', 'W', 'r', 'd'] )

# => [["H", "e"], ["l", "l"], ["o", "W"], ["o", "r"], ["l", "d"]]

# transpose

[["H", "e"], ["l", "l"], ["o", "W"], ["o", "r"], ["l", "d"]].transpose

# => [["H", "l", "o", "o", "l"], ["e", "l", "W", "r", "d"]]

# product

[:a,:b,:c].product [1,2,3]

# => [[:a, 1], [:a, 2], [:a, 3], [:b, 1], [:b, 2], [:b, 3], [:c, 1], [:c, 2], [:c, 3]]

# combination (no repetitions of pairings)

[:a,:b,:c,:d].combination(2).to_a

# => [[:a, :b], [:a, :c], [:a, :d], [:b, :c], [:b, :d], [:c, :d]]

# permutation (will give both [a,b] and [b,a])

[:a,:b,:c].permutation(2).to_a

# => [[:a, :b], [:a, :c], [:b, :a], [:b, :c], [:c, :a], [:c, :b]]

# reverse and reverse!

[1,2,3].reverse

# => [3, 2, 1]

# sort and sort!

[2,1,3].sort

# => [1, 2, 3]

# shuffle and shuffle!

[1,2,3].shuffle

# => [3, 1, 2]

# uniq and uniq!

[2,1,3,3,1,2].uniq

# => [2, 1, 3]

# rotate and rotate!

[:a,:b,:c].rotate

# => [:b, :c, :a]

# compact and compact!

[:a,:b,nil,nil,nil,:c].compact

# => [:a, :b, :c]

# flatten and flatten!

[["H", "e"], ["l", "l"], ["o", "W"], ["o", "r"], ["l", "d"]].flatten

# => ["H", "e", "l", "l", "o", "W", "o", "r", "l", "d"]

Slicing


# slice and slice!
[1,2,3,4,5,6,7,8].slice(2)
# => 3 

[1,2,3,4,5,6,7,8][2]
# => 3 

[1,2,3,4,5,6,7,8].slice(2..5)
# => [3, 4, 5, 6] 

[1,2,3,4,5,6,7,8][2..5]
# => [3, 4, 5, 6] 

[1,2,3,4,5,6,7,8].slice(2,5)
# => [3, 4, 5, 6, 7]

[1,2,3,4,5,6,7,8][2,5]
# => [3, 4, 5, 6, 7]

# Enumerables
[8,7,6,5,4,3,2,1].slice_after(2).to_a
# => [[8, 7, 6, 5, 4, 3, 2], [1]]
 
[8,7,6,5,4,3,2,1].slice_before(2).to_a
# => [[8, 7, 6, 5, 4, 3], [2, 1]]

[1,2,4,9,10,11,12,15,16,19,20,21].slice_when {|i,j| i+1 != j}.to_a
# => [[1, 2], [4], [9, 10, 11, 12], [15, 16], [19, 20, 21]]

# slice and slice!

[1,2,3,4,5,6,7,8].slice(2)

# => 3

[1,2,3,4,5,6,7,8][2]

# => 3

[1,2,3,4,5,6,7,8].slice(2..5)

# => [3, 4, 5, 6]

[1,2,3,4,5,6,7,8][2..5]

# => [3, 4, 5, 6]

[1,2,3,4,5,6,7,8].slice(2,5)

# => [3, 4, 5, 6, 7]

[1,2,3,4,5,6,7,8][2,5]

# => [3, 4, 5, 6, 7]

# Enumerables

[8,7,6,5,4,3,2,1].slice_after(2).to_a

# => [[8, 7, 6, 5, 4, 3, 2], [1]]

[8,7,6,5,4,3,2,1].slice_before(2).to_a

# => [[8, 7, 6, 5, 4, 3], [2, 1]]

[1,2,4,9,10,11,12,15,16,19,20,21].slice_when {|i,j| i+1 != j}.to_a

# => [[1, 2], [4], [9, 10, 11, 12], [15, 16], [19, 20, 21]]

Adding


[2,3,4] + [5,6,7]
# => [2, 3, 4, 5, 6, 7] 

[2,3,4] << [5,6,7]
# => [2, 3, 4, [5, 6, 7]]

[2,3,4] .concat [5,6,7]
# => [2, 3, 4, 5, 6, 7] 

[2,3,4] .unshift [5,6,7]
# => [[5, 6, 7], 2, 3, 4]

[2,3,4] .push [5,6,7]
# => [2, 3, 4, [5, 6, 7]]

[2,3,4] | [3,4,5,6,7]
# => [2, 3, 4, 5, 6, 7]

[2,3,4] + [5,6,7]

# => [2, 3, 4, 5, 6, 7]

[2,3,4] << [5,6,7]

# => [2, 3, 4, [5, 6, 7]]

[2,3,4] .concat [5,6,7]

# => [2, 3, 4, 5, 6, 7]

[2,3,4] .unshift [5,6,7]

# => [[5, 6, 7], 2, 3, 4]

[2,3,4] .push [5,6,7]

# => [2, 3, 4, [5, 6, 7]]

[2,3,4] | [3,4,5,6,7]

# => [2, 3, 4, 5, 6, 7]

Replace & Remove


[2,3,4] .replace [4,5,6]
# => [4, 5, 6]

x = [1,2,3,4,5]
x.pop
# => 5 
x
# => [1, 2, 3, 4] 

x.shift
# => 1 
x
# => [2, 3, 4]

x.clear
# => []

x = [1,2,3,4,5]
x.delete(2)
# => 2 
x
# => [1, 3, 4, 5] 

x.delete_at(3)
# => 5 
x
# => [1, 3, 4] 

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

[1,2,3,4,5,6,7,8].delete_if {|n| n.even? && n > 4}
# => [1, 2, 3, 4, 5, 7]

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

[:a,:b,:c,:d,:e] - [:a,:e]
# => [:b, :c, :d]

[2,3,4] .replace [4,5,6]

# => [4, 5, 6]

x = [1,2,3,4,5]

x.pop

# => 5

# => [1, 2, 3, 4]

x.shift

# => 1

# => [2, 3, 4]

x.clear

# => []

x = [1,2,3,4,5]

x.delete(2)

# => 2

# => [1, 3, 4, 5]

x.delete_at(3)

# => 5

# => [1, 3, 4]

[1,2,3,4,5,6,7,8].delete_if(&:even?)

# => [1, 3, 5, 7]

[1,2,3,4,5,6,7,8].delete_if {|n| n.even? && n > 4}

# => [1, 2, 3, 4, 5, 7]

[1,2,3,4,5,6,7,8].keep_if(&:odd?)

# => [1, 3, 5, 7]

[:a,:b,:c,:d,:e] - [:a,:e]

# => [:b, :c, :d]

Selecting


# Already covered are keep_if, delete_if, slice, []

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

[1,2,3,4,5,6,7,8].select {|n| n < 3 || n > 5}
# => [1, 2, 6, 7, 8]

[1,2,3,4,5,6,7,8].detect(&:even?) # Detect gets first truth result
# => 2

[1,2,3,4,5,6,7,8].values_at(2)
# => [3] 

[1,2,3,4,5,6,7,8].values_at(2,4)
# => [3, 5] 

[1,2,3,4,5,6,7,8].values_at(2,4,5)
# => [3, 5, 6] 

[1,2,3,4,5,6,7,8].values_at(2..5)
# => [3, 4, 5, 6]

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

[1,2,3,4,5,6,7,8].find {|i| i.even?}
# => 2

[1,2,3,4,6,8,9,11,13,14,15,16].chunk(&:even?).to_a
# => [[false, [1]], [true, [2]], [false, [3]], [true, [4, 6, 8]], [false, [9, 11, 13]], [true, [14]], [false, [15]], [true, [16]]]

[1,2,3,4,5,6,7,8].take(3)
# => [1, 2, 3]

[1,2,3,4,5,6,7,8].group_by(&:even?)
# => {false=>[1, 3, 5, 7], true=>[2, 4, 6, 8]}

[2,3,4] .partition {|i| i.even?}.to_a
# => [[2, 4], [3]]

[0,1,2,3,4,5,6,7,9].group_by.with_index {|_,index| index % 4 }.values
# => [[0, 4, 9], [1, 5], [2, 6], [3, 7]]

# Already covered are keep_if, delete_if, slice, []

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

# => [2, 4, 6, 8]

[1,2,3,4,5,6,7,8].select {|n| n < 3 || n > 5}

# => [1, 2, 6, 7, 8]

[1,2,3,4,5,6,7,8].detect(&:even?) # Detect gets first truth result

# => 2

[1,2,3,4,5,6,7,8].values_at(2)

# => [3]

[1,2,3,4,5,6,7,8].values_at(2,4)

# => [3, 5]

[1,2,3,4,5,6,7,8].values_at(2,4,5)

# => [3, 5, 6]

[1,2,3,4,5,6,7,8].values_at(2..5)

# => [3, 4, 5, 6]

# reject and reject!

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

# => [1, 3, 5, 7]

[1,2,3,4,5,6,7,8].find {|i| i.even?}

# => 2

[1,2,3,4,6,8,9,11,13,14,15,16].chunk(&:even?).to_a

# => [[false, [1]], [true, [2]], [false, [3]], [true, [4, 6, 8]], [false, [9, 11, 13]], [true, [14]], [false, [15]], [true, [16]]]

[1,2,3,4,5,6,7,8].take(3)

# => [1, 2, 3]

[1,2,3,4,5,6,7,8].group_by(&:even?)

# => {false=>[1, 3, 5, 7], true=>[2, 4, 6, 8]}

[2,3,4] .partition {|i| i.even?}.to_a

# => [[2, 4], [3]]

[0,1,2,3,4,5,6,7,9].group_by.with_index {|_,index| index % 4 }.values

# => [[0, 4, 9], [1, 5], [2, 6], [3, 7]]

Mapping…

December 11, 2015 by Daniel P. Clark

Faith Defined

The meaning of the word faith has been broken by media and many in society. It’s become more synonymous with “magical” wishful thinking. “You keep using that word; I do not think it means what you think it means”. Michael Ramsden has quite well expressed the rational behind the typical understanding of faith. In the…

December 7, 2015 by Daniel P. Clark

Insecurity

Insecurity – “uncertainty or anxiety about oneself; lack of confidence.” Where does it come from? Why does it exist? There are times when we need to take a deeper look at ourselves and identify what potential insecurities we may have and how to deal with them. Thinking on it I think of a young baby…

Page 2 of 11

« Previous 1 2 3 4 … 11 Next »