Let’s CodeSameer Soni care@redpanda.co.in

–C.A.R. Hoare, The 1980 ACM Turing Award Lecture

“There are two ways of constructing a software design: One way is to make it so simple that there

are obviously no deficiencies and the other way is to make it so complicated that there are no obvious

deficiencies.”

– E. W. Dijkstra

“The computing scientist’s main challenge is not to get confused by the complexities of his own

making.”

Kata• is a Japanese word. • are detailed choreographed patterns of

movements practised either solo or in pairs.

• originally were teaching and training methods by which successful combat techniques were preserved and passed on.

• Practicing kata allowed a company of persons to engage in a struggle using a systematic approach, rather than as individuals in a disorderly manner.

• basic goal of kata is to preserve and transmit proven techniques and to practice self-defence.

• is a term used by some Software Craftsmen, who write small snippets of code to build muscle memory and practise craft much like soldier, musician, dancer or doctor.

- wiki

Ruby Functional Programming

Statement was incorrect until we were in school and hadn’t been introduced to PROGRAMMING.

Expression is quite common in Imperative style of programming.

But we don’t realise the side effects and pay heavy cost.

x = x + 1

TheoryFunctional programming treats computation as evolution of mathematical functions and avoids state and mutable data.

Promotes code with no side effects, no change in value of variables.

Discourages change of state.

Cleaner Code - Variables are not modified once defined.

Referential transparency - Expressions can be replaced by functions, as for same input always gives same output.

Advantages

Benefits of RT: 1. Parallelization 2. Memoization 3. Modularization 4. Ease of debugging

Rules - Don’t update variables

No • indexes = [1,2,3] • indexes << 4 • indexes # [1,2,3,4]

Yes • indexes = [1,2,3] • all_indexes = indexes + [4] #[1,2,3,4]

Don’t append to arrays or strings

No • hash = {a: 1, b: 2} • hash[:c] = 3 • hash

Yes • hash = {a: 1, b: 2} • new_hash = hash.merge(c: 3)

Don’t update hashes

No • string = “hello” • string.gsub!(/l/, 'z') • string # “hezzo

Yes • string = "hello" • new_string = string.gsub(/l/, 'z') # "hezzo"

Don’t use bang methods which modify in place

No • number = gets • number = number.to_i

Here, we are not updating number but overriding the old values, which is as bad as updating. Rule is: Once defined, its value should remain same in that scope

Yes • number_string = gets • number = number_string.to_i

Don’t reuse variables

Blocks as higher order functionsA block is an anonymous piece of code you can pass around and execute at will.

No • dogs = [] • ["milu", "rantanplan"].each do |name|

dogs << name.upcase end

• dogs # => ["MILU", "RANTANPLAN"]

Yes • dogs = ["milu", "rantanplan"].map do |name|

name.upcase end # => ["MILU", "RANTANPLAN"]

init-empty + each + push = map

No • dogs = [] • ["milu", "rantanplan"].each do |name|

if name.size == 4 dogs << name end end

• dogs # => [“milu"]

Yes • dogs = ["milu", "rantanplan"].select do |name|

name.size == 4 end # => ["milu"]

init-empty + each + conditional push = select/reject

No • length = 0 • ["milu", "rantanplan"].each do |dog_name|

length += dog_name.length end

• length # 14

Yes • length = ["milu", "rantanplan"].inject(0) do |accumulator, dog_name|

accumulator + dog_name.length end # => 14

initialize + each + accumulate = inject

1st way: hash = {} input.each do |item| hash[item] = process(item) end hash

How to create hash from an enumerable

2nd way: Hash[input.map do |item| [item, process(item)] end]

input.inject({}) do |hash, item| hash.merge(item => process(item)) end

# Way 1

if found_dog == our_dog name = found_dog.name message = "We found our dog #{name}!" else message = "No luck" end

Everything is a expression

# Way 2

message = if (found_dog == my_dog) name = found_dog.name "We found our dog #{name}!" else "No luck" end

Exercise

"What's the sum of the first 10 natural number whose square value is divisible by 5?"

Ruby Functional wayInteger::natural.select { |x| x**2 % 5 == 0 }.take(10).inject(:+) #=> 275

Ruby Imperative way

n, num_elements, sum = 1, 0, 0 while num_elements < 10 if n**2 % 5 == 0 sum += n num_elements += 1 end n += 1 end sum #=> 275

Source • wikipedia.com • code.google.com

Thanks