let's code

Download Let's code

Post on 13-Jul-2015




0 download

Embed Size (px)


  • Lets 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


  • E. W. Dijkstra

    The computing scientists main challenge is not to get confused by the complexities of his own


  • 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 hadnt been introduced to PROGRAMMING.

    Expression is quite common in Imperative style of programming.

    But we dont 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.


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

  • Rules - Dont update variables

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

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

    Dont update hashes

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

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

    Dont 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

    Dont 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 ["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 [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