Learning to code is a path full of struggles, and learning isn't the exception. But you'll agree with me, that practice is the best way to learn and develop your skills. Ruby Out there are plenty of sites to choose from where you can achieve this. But after n amount of solved challenges, you'll start questioning your solutions. You'll start feeling, that is not enough to come up with an answer to the challenge. And you'll be wondering if there is a better, faster, and less consuming memory approach. If this is your case, if you have reached this stage, then you're more than ready to begin benchmarking your code. And if you're not, well, let me tell you that learning this will step up your game. So, what is this "benchmarking" thing anyway?... Benchmarking is the process of measuring the performance of something... in this case the performance of your code. Benchmarking is the process of measuring the performance of something. And that's it, there is nothing more to add. Yeah, I know what you're thinking, that knowing the meaning doesn't serve your purpose. But I'm positive that at least it will give you a broad idea. With this in mind, the next question to answer is, "How benchmarking my code, will help me improve my coding skills?". This is an easy one. Benchmarking gives you knowledge, and knowledge is power. The better understanding of your code, the better code you'll start programming. Is that simple!. Benchmarking gives you knowledge, and knowledge is power. Benchmarking gives you a simple view of how your code is performing. This view focuses on three main areas: , , and . elapsed time memory iterations per second Elapsed time: is the amount of time your code takes to finish a task. Memory: is the allocated space in your drive that your code occupies to solve the task. Iterations per second: is the total number of repetitions your code can do the same task, over and over, in a second. Ok, at this point I assume you have understood the basics of benchmarking. Hopefully, you are also saying to yourself - "Yeah, this is what I was missing, this will help me become a better programmer!". If you don't think that way yet; I hope knowing how it works will do. Now, how do we apply this? Ruby makes it easy for us, as it already has a " " class, but we'll complement it with two other ruby gems. Benchmarking Benchmarking-ips Benchmarking-memory Before describing the steps to benchmark your code. I'm assuming you are using a /unix distribution, and have a working version of Ruby installed. linux If you're running some other OS like Windows, the next series of commands, probably, won't work. But the benchmarking steps are going to be identical. Let's begin!. is to install this in your system; for that, you can use this command: a. The first step rubygems gem install benchmark-ips benchmark-memory is creating a ruby file, I'm going to call it "benchmarking_ruby.rb", but you can name it in any way you want: b. The second step touch benchmarking_ruby.rb Open the file with your preferred text editor. This file will contain three main sections: b.1 Here we use to include and grant our file access to the gems recently installed and the Ruby Benchmark Class. Doing so, will allow us to use the benchmark methods to measure our code performance. - Section 1: require require 'benchmark' require 'benchmark/memory' require 'benchmark/ips' - We write the code that we want to benchmark. Section 2: def method_1 (params) # some code end def method_2 (params) # some code end Note: Benchmark works if you want to measure a single method but it's best if you test at least two or more. Don't worry too much about this right now, later on, I'll show you an example and you'll understand what I meant. We set up the test. - Section 3: This part is tricky but not complicated. Look at the image below and try to identify what's happening. Benchmark.bmbm x.report ( ) { method_1(params) }
        x.report ( ) { method_2(params) } Benchmark.memory x.report ( ) { method_1(params) }
        x.report ( ) { method_2(params) }
        x.compare! Benchmark.ips x.report ( ) { method_1(params) }
        x.report ( ) { method_2(params) }
        x.compare! benchmark(params) def benchmark (params) do |x| "Method One" "Method Two" end do |x| "Method One" "Method Two" end do |x| "Method One" "Method Two" end end We are declaring a method called " " that accepts some parameters (or arguments). benchmark ... def benchmark (params) end Inside it, we are using three Class methods, ::bmbm, ::memory and ::ips, and we are passing them a block. Benchmark.bmbm Benchmark.memory Benchmark.ips def benchmark (params) do |x| # ::bmbm will measure the "ELAPSED TIME" end do |x| # ::memory will measure the "ALLOCATED MEMORY" end do |x| # ::ips will measure "ITERATIONS PER SECOND" end end Notice the comments inside each block? The inner part of each block contains a method that accepts a string and also a block. The string acts as a short description, and in the block, we call the methods we wrote in . report Section 2 ...
    Benchmark.bmbm |x|
        x.report ( ) { # method call }
    end
... do "description or identifier" Important: all benchmark blocks (::bmbm, ::memory and ::ips) use the same methods. Except for the last two (::memory and :: ips), they use an extra method called #compare!. ...
    Benchmark.memory x.report ( ) { method_1(params) }
        x.report ( ) { method_2(params) }
        x.compare! ... do |x| "Method One" "Method Two" end The last bit in our file is just the call for the method. "benchmark" benchmark(params) And last but not least, is to save your changes and run the ruby script you have created. c) The third step ruby bencharking_ruby.rb I'm sure by now, you think this is interesting and you wanna give it a try. Until now I have only shown you how to set things up so you can benchmark your code. But, How does it actually look? Let's use what we have learned in a real example. Imagine that you have been asked to sum all the elements inside an array and you have to do it in the most efficient way. [*( .. )] # You're given an array with n elements inside it. # Your task is to print the sum fo all elements in # the most efficient way possible. # Input 0 1_000_000 # ordered array of one million elements. # Output 500_000_500_000 You start to think about it, and after some time you have come up with four solutions. But you don't know which one is better. sum = i = i < arr.size
    sum += arr[i]
    i += sum sum = arr.each sum += num sum arr.sum arr.inject(& ) # Solution 1: sum all elements using a "while loop". def sum_1 (arr) 0 0 while 1 end end # Solution 2: sum all elements using the "each" method. def sum_2 (arr) 0 do |num| end end # Solution 3: sum all elements using the "sum" method. def sum_3 (arr) end # Solution 4: sum all elements using the "inject" method. def sum_4 (arr) :+ end At this time you remember that you learn to benchmark your code by reading a random article in and you set up your benchmarking environment. hackernoon You create your file. touch sum_array_elements.rb You made the corresponding changes and put in your code. sum = i = i < arr.size
    sum += arr[i]
    i += sum sum = arr.each sum += num sum arr.sum arr.inject(& ) puts Benchmark.bmbm x.report ( ) { sum_1(arr) }
    x.report ( ) { sum_2(arr) }
    x.report ( ) { sum_3(arr) }
    x.report ( ) { sum_4(arr) } puts Benchmark.memory x.report ( ) { sum_1(arr) }
    x.report ( ) { sum_2(arr) }
    x.report ( ) { sum_3(arr) }
    x.report ( ) { sum_4(arr) }
    x.compare! puts Benchmark.ips x.report ( ) { sum_1(arr) }
    x.report ( ) { sum_2(arr) }
    x.report ( ) { sum_3(arr) }
    x.report ( ) { sum_4(arr) }
    x.compare! arr = [*( .. )]

benchmark(arr) require "benchmark" require "benchmark-memory" require "benchmark/ips" def sum_1 (arr) 0 0 while 1 end end def sum_2 (arr) 0 do |num| end end def sum_3 (arr) end def sum_4 (arr) :+ end def benchmark (arr) "--- Elapsed Time ----------------------" do |x| "while loop" "#each" "#sum" "#inject" end "--- Memory ----------------------------" do |x| "while loop" "#each" "#sum" "#inject" end "--- Iterations per Second -------------" do |x| "while loop" "#each" "#sum" "#inject" end end 0 1_000_000 You run the script. ruby sum_array_elements.rb And you get the result. --- Elapsed Time ---------------------------------------

Rehearsal ---------------------------------------------- loop   0.066358   0.000000   0.066358 (  0.069475) ------------------------------------- total: 0.296684sec

                 user     system      total        real loop   0.056899   0.000016   0.056915 (  0.058878) --- Memory ---------------------------------------------

Calculating ------------------------------------- loop     0.000  memsize (     0.000  retained)
                         0.000  objects (     0.000  retained)
                         0.000  strings (     0.000  retained) 0.000  objects (     0.000  retained)
                         0.000  strings (     0.000  retained) 0.000  objects (     0.000  retained)
                         0.000  strings (     0.000  retained) 0.000  objects (     0.000  retained)
                         0.000  strings (     0.000  retained)

Comparison: loop:          0 allocated --- Iterations per Second ------------------------------

Warming up -------------------------------------- loop     1.000  i/100ms Calculating ------------------------------------- loop     19.848  (±10.1%) i/s -     99.000 5.021740s Comparison: loop:       19.8 i/s - 21.66x  (± 0.00) slower while #each        0.068786   0.000000   0.068786 (  0.070810) #sum         0.001983   0.000000   0.001983 (  0.002005) #inject      0.158601   0.000956   0.159557 (  0.163468) while #each        0.082691   0.000000   0.082691 (  0.085142) #sum         0.002014   0.000000   0.002014 (  0.002128) #inject      0.156500   0.001905   0.158405 (  0.163096) while #each     0.000  memsize (     0.000  retained) #sum     0.000  memsize (     0.000  retained) #inject     0.000  memsize (     0.000  retained) while #each:          0 allocated - same #sum:          0 allocated - same while #each     1.000  i/100ms #sum    42.000  i/100ms #inject     1.000  i/100ms while in #each     14.161  (± 7.1%) i/s -     71.000  in   5.037058s #sum    430.010  (± 5.1%) i/s -      2.184k in   5.092623s #inject      6.405  (±15.6%) i/s -     32.000  in   5.031657s #sum:      430.0 i/s while #each:       14.2 i/s - 30.37x  (± 0.00) slower #inject:        6.4 i/s - 67.13x  (± 0.00) slower As I said before, benchmarking your code gives you knowledge and knowledge is power. But, what's the kind of power that you're getting? Well, let's analyze the output so you could appreciate the of advantages of benchmarking. Remember you were asked to deliver the most efficient solution so let's start with the first part: Elapsed Time --- Elapsed Time ---------------------------------------

Rehearsal ---------------------------------------------- loop   0.066358   0.000000   0.066358 (  0.069475) ------------------------------------- total: 0.296684sec

                 user     system      total        real loop   0.056899   0.000016   0.056915 (  0.058878) while #each        0.068786   0.000000   0.068786 (  0.070810) #sum         0.001983   0.000000   0.001983 (  0.002005) #inject      0.158601   0.000956   0.159557 (  0.163468) while #each        0.082691   0.000000   0.082691 (  0.085142) #sum         0.002014   0.000000   0.002014 (  0.002128) #inject      0.156500   0.001905   0.158405 (  0.163096) As you can see, the first test "Benchmark::bmbm", throw us the amount of time the solutions took to sum all elements. If you look at the last column in the second row you'll see the "Real" time for each one of them. From this first part, we can assume that the best solution at the moment is the #sum method. It only took  0.002128 seconds to complete the task. So which method is the most efficient one?. It's nonconclusive. We still have to review the other results. Memory --- Memory ----------------------------------------

Calculating ------------------------------------- loop     0.000  memsize (     0.000  retained)
                         0.000  objects (     0.000  retained)
                         0.000  strings (     0.000  retained) 0.000  objects (     0.000  retained)
                         0.000  strings (     0.000  retained) 0.000  objects (     0.000  retained)
                         0.000  strings (     0.000  retained) 0.000  objects (     0.000  retained)
                         0.000  strings (     0.000  retained)

Comparison: loop:          0 allocated while #each     0.000  memsize (     0.000  retained) #sum     0.000  memsize (     0.000  retained) #inject     0.000  memsize (     0.000  retained) while #each:          0 allocated - same #sum:          0 allocated - same #inject:          0 allocated - same In this case, it's a tie. Every method seems efficient, none of them is using space in your hard drive. We can tell by looking at the section. "Comparison" At this point, every method still has a chance of proving that if they are the best solution to the problem. So we analyze the last part. Iterations per Second --- Iterations per Second ------------------------------

Warming up -------------------------------------- loop     1.000  i/100ms Calculating ------------------------------------- loop     19.848  (±10.1%) i/s -     99.000 5.021740s Comparison: loop:       19.8 i/s - 21.66x  (± 0.00) slower while #each     1.000  i/100ms #sum    42.000  i/100ms #inject     1.000  i/100ms while in #each     14.161  (± 7.1%) i/s -     71.000  in   5.037058s #sum    430.010  (± 5.1%) i/s -      2.184k in   5.092623s #inject      6.405  (±15.6%) i/s -     32.000  in   5.031657s #sum:      430.0 i/s while #each:       14.2 i/s - 30.37x  (± 0.00) slower #inject:        6.4 i/s - 67.13x  (± 0.00) slower Again if we look at the "Comparison" results we observe an outstanding result. The #sum method is 21 times faster than the closest competitor. That is incredible!. With all the sections analyzed. We now can conclude that the best way to approach this task is to use the #sum method. It was the fastest to solve the task, it didn't use any memory at all, and it was able to iterate 430 times per second. Conclusion Benchmarking your ruby code will make you a better programmer. Doing it will give useful information, and will help you link your ideas to facts, not perceptions. Also, it will save you from lots of "Runtime Errors". Thanks for taking your time reading this, I hope you benefit from it, as I have.

Mind

How To Create an AWS Account For Personal Use

Learn HTML & CSS: The Best FREE Online Resources for Beginners

Read My Stories

Too Long; Didn't Read

Make resilience your competitive advantage

How Benchmarking Your Code Will Improve Your Ruby Skills

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

Untitled Story

Profiling: the obvious step after Benchmarking your Ruby code.

3 Easy Ways to Improve The Performance Of Your Python Code

5 Performance Tips For .Net Developers

A Benchmark of Low Code Platforms for Test Automation

A brief overview of Automatic Machine Learning solutions (AutoML)

Profiling: the obvious step after Benchmarking your Ruby code.

3 Easy Ways to Improve The Performance Of Your Python Code

5 Performance Tips For .Net Developers

A Benchmark of Low Code Platforms for Test Automation

A brief overview of Automatic Machine Learning solutions (AutoML)

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps