Your SlideShare is downloading. ×
Ruby Code Optimizations (for beginners)
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×

Introducing the official SlideShare app

Stunning, full-screen experience for iPhone and Android

Text the download link to your phone

Standard text messaging rates apply

Ruby Code Optimizations (for beginners)

1,822
views

Published on

A small presentation explaining a limited set of good practices and code optimization techniques in Ruby and Ruby on Rails for beginners.

A small presentation explaining a limited set of good practices and code optimization techniques in Ruby and Ruby on Rails for beginners.

Published in: Technology, Education

0 Comments
4 Likes
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total Views
1,822
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
31
Comments
0
Likes
4
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 1. Code Optimizations
    Ruby
    1
    28 minutes
  • 2. Huh? What’s that?
    2
  • 3. Why would I want to do that?
    Money
    Resources
    Hardware
    People (Developers)
    Time
    Speed of operation
    Developer takes to figure out what’s going on
    Karma
    No one wants to write bad code!
    3
  • 4. 4
    Ruby
  • 5. Interpolation over Concatenation
    puts "This string embeds #{a} and #{b} through interpolation"# => faster
    puts "This string concatenates "<< a <<" and "<< b # => slower
    puts "This string concatenates “+ a +" and "+ b # => slower
    5
  • 6. Destructive Operations!
    hash = {}
    hash =hash.merge({1=>2})
    # duplicates the original hash
    hash.merge!({1=>2})
    # equivalent to previous line, and faster
    str="string to gsub"
    str=str.gsub(/to/, 'copy')
    # duplicate string and reassigns it
    str.gsub!(/to/, 'copy')
    # same effect, but no object duplication
    6
  • 7. Benchmark everything
    require 'benchmark'
    n =100000
    Benchmark.bm do |x|
    x.report('copy') { n.timesdo ; h = {}; h =h.merge({1=>2}); end }
    x.report('no copy') { n.timesdo ; h = {}; h.merge!({1=>2}); end }
    end
    # user system total real
    # copy 0.460000 0.180000 0.640000 (0.640692)
    # no copy 0.340000 0.120000 0.460000 (0.463339)
    7
  • 8. Symbols whenever possible
    'foo'.object_id# => 23233310
    'foo'.object_id# => 23228920
    :foo.object_id# => 239298
    :foo.object_id# => 239298
    8
  • 9. Array joins
    [1, 2, 3] * 3
    # => [1, 2, 3, 1, 2, 3, 1, 2, 3]
    [1, 2, 3] * '3'# => "13233" 
    %w{thisisatest} * ", "
    # => "this, is, a, test" 
    h = { :name=>"Fred", :age=>77 }
    h.map { |i| i * "=" } * " "
    # => "age=77 name=Fred"
    9
  • 10. Everything is an object!
    defadd(adder, addee)
    adder +addee
    end 
    add(3,5) # => 8
    classFixnum
    defadd(num)
    self+ num
    end
    end
    3.add(5)# => 8
    10
  • 11. Use ranges instead of complex comparisons for numbers
    # No more if x > 1000 && x < 2000 nonsense. Instead:
    year =1972
    puts case year
    when1970..1979:"Seventies"
    when1980..1989:"Eighties"
    when1990..1999:"Nineties"
    end
    11
  • 12. Ruby logic
    defis_odd(x)
    if x % 2==0
    returnfalse
    else
    returntrue
    end
    end
    defis_odd(x)
    x % 2==0?false:true
    end
    defis_odd(x)
    x % 2!=0
    end
    12
    classFixnum
    def odd?
    self % 2!=0
    end
    end
    2.odd? # => false
  • 13. Enumerate single object
    # [*items] converts a single object into an array. And if the object is an array, keeps it as it is.
    [*items].each do |item|
    # ...
    end
    13
  • 14. 14
    Rails
  • 15. Caching
    Page Caching
    Fragment Caching
    Action Caching
    Caching into Local / Instance Variable
    15
    # Makes a database query only if @current_user is nil
    defcurrent_user
    @current_user||=User.find(session[:user_id])
    end
  • 16. Don’t limit yourself to ActiveRecord
    Use performance boosting database
    features like:
    Stored procedures
    Functions
    X-query
    16
  • 17. Finders are great but be careful
    Retrieve only the information that you need. 
    Don’t kill your database with too many queries. Use eager loading.
    Avoid dynamic finders like MyModel.find_by_*.
    Need an optimized query? Run MyModel.find_by_sql.
    17
    #This will generates only one query,
    # rather than Post.count + 1 queries
    for post inPost.find(:all, :include=> [ :author, :comments ])
    # Do something with post
    end
  • 18. Control your controllers
    Don’t let them become the God classes.
    Lesser instance variables.
    Slimmer the better.
    Appropriate code in appropriate controller.
    18
  • 19. 19
    And of course!
  • 20. 20
    Obey design principles.
    Always code in context (Objects). It is the best way to model your solution.
    Avoid “Quick and dirty”.
    Understand that no good can ever come out of duplication. Be it code, design, data and most importantly effort.
    Simplicity is the key.
    Enjoy coding!
  • 21. 21
    Slides
    slideshare.net/ihower/rails-best-practices
    slideshare.net/ihower/practical-rails2-350619
    slideshare.net/preston.lee/logical-programming-with-ruby-prolog
    Ruby Books
    The Ruby Wayby Hal Edwin Fulton, Guy Hurst
    The Rails Way by Obie Fernandez
    Design Patterns in Rubyby Russ Olsen
    Software Construction
    Code Complete 2 by Steve McConnell
    The Pragmatic Programmer: From Journeyman to Masterby Andrew Hunt