In Merge Sort, you divide a list of items to be in the smallest units possible. You sort the smaller units, then repeatedly merge the small units back together until you have a sorted list.

1. Take an array of items. Split the array into single subunits.
2. Since an item with only one input is considered sorted, merge the subunits together so that you now have subunits with 2 items each.
3. Sort each of these 2-item subunits so that they are all ordered correctly.
4. Continue merging the subunits together and sorting them individually until you have a completely merged and sorted list.

As discussed, Merge Sort has a very good time complexity. However, it does not have a good space complexity. Because it doesn’t sort in place (like Bubble Sort), you need twice the space of the normal list in order to implement the sort. Despite this drawback, it is still worthwhile because of its efficiency. For example, Merge Sort’s worst case time complexity O(n log n) is the same as Quicksort’s best case time complexity.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

class MergeSort
    def sort(array)

        if array.length <= 1
          return array
        end

        middle = (array.length / 2.0).round
        length = array.length

        first_array = array[0...middle]
        second_array = array[middle...length]

        first_sorted_array = sort(first_array)
        second_sorted_array = sort(second_array)

        return merge(first_sorted_array, second_sorted_array)
    end

    def merge(first_array, second_array)

        return second_array if first_array.empty?
        return first_array if second_array.empty?

        if first_array.first <= second_array.first
            unit = first_array.shift
        else
            unit = second_array.shift
        end

        return [unit] + merge(first_array, second_array)
    end
end
print MergeSort.new.sort([4,1,6,3,5,2]) #=> [1, 2, 3, 4, 5, 6]

This is the third post in a series of posts on various sorting algorithms in computer science. See the entire series here.

JavaScript is a dynamically-typed, object-oriented programming language that is usually used on the client side in web browsers.

Functions are central to one’s undertanding of JavaScript, so let’s start with the difference between function declarations and function expressions.

Function Declarations vs. Function Expressions

A function declaration, or function statement, is when you define a function without a variable assignment. A function expression is when you define a function and set the result of that function equal to a varialbe.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

 //Function Declaration

    //Named function
    function foo(){
      return "hello";
    }

    foo() //=> "hello"

  // Function Expressions

    // Anonymous Function:
    var a = function(){
      return "hello";
    }

    a() //=> "hello"

    // Named Function:
    var a = function foo(){
      return "hello";
    }

    foo() //=> "hello"
    a() //=> "hello"

Scoping

In JavaScript, you have global scope and local scope. If a variable is defined outside of any function, it is considering to be a global variable, which can be accessed by any function. It is scoped to the entire document.

If the variable is defined inside of a function, that variable is scoped to that function and is only accessible to that function.

1
2
3
4
5
6
7
8
9
10

  var a = 0; // This is a global variable.

  function foo(){
    var b = 1; // This is a local variable.
  }

  // If you try to call a and b outside of any function, you get:

  a //=> 0
  b //=> "b is undefined"

Hoisting

One unique quirk in JavaScript is variable and function hoisting. Function declarations and function variables are always moved to the top of their scope by the interpreter.

Since all variables defined in a function are scoped to the function level, any variables declared throughout the function are initialized as undefined at the beginning of the function. They are given a value when it reaches the variable assignment. Forward referencing is not possible for variables because the assignment itself isn’t hoisted, just the initialization is.

However, forward referencing for function declarations is possible because placement is irrelevant for simple function declarations. All function declarations are automatically moved to the top of the function.

Let’s look at some examples.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

function foo(){
    function bar() {
        return "hi";
    }
    return bar();
    function bar() {
        return "bye";
    }
}

foo() //=> "bye"

/* Even though the second bar function declaration is below the 
return statement, the interpreter actually sees it above the return 
because it hoists all the function declarations to the top: */

function foo(){
    function bar() {
        return "hi";
    }
    function bar() {
        return "bye";
    } // redefines bar
    return bar();
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

function foo(){
    var a = "hi";
    return a;
    var a = "bye";
}
foo() //=> "hi"

function foo(){
    return a;
    var a = "hi";
    var a = "bye";
}
foo() //=> "undefined"

// These are read like this:

function foo(){
    var a = "undefined"; // Variable in function initialized.
    var a = "hi"; // Variable assigned value.
    return a; // Current assignment "hi" returned.
    var a = "bye"; // Variable assignment redefined.  
}

function foo(){
    var a = "undefined"; // Variable in function initialized.
    return a; // Current assignment "undefined" returned.
    var a = "hi"; // Variable assignment.
    var a = "bye"; // Variable assignment redefined.
}

/* Further, if you simply redefine a variable inside a function,
that variable is a global variable which is initialized as undefined
in the document, like so: */

  function foo(){
    b = 1;
  }

  // is read as => 

  var b = "undefined"; // Variable initialized.

  function foo(){
    b = 1; // Variable reassigned.
  }

/* So it's important to inlclude `var` if you desire to limit 
the scope to the current function. */

To prevent variable hoising, you can use self-executing anonymous functions, also known as immediately-invoked function expressions (IIFEs).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// Normal function:

var a = "hi";

var word = function(){
  return a;
};

var a = "bye";

word() //=> "bye"

// IIFE: 

var a = "hi";

var word = (function(){
  return a;
}(a));

var a = "bye";

word //=> "hi"

As you can see, IIFEs preserve the context of the origin function expression placement by passing the current state of the variable to the function.

Object-Orientation

Coming from Ruby, I had a good understanding of OOP before learning JS. However, object-oriented programming in JavaScript is a bit different.

You can create an object literal using a basic hash:

1

var Amber = {name: "Amber", favoriteLanguage: "JavaScript"};

If you only need to ever use the object once, this technique is fine. But if you want to create multiple instances of it, you should use constructor functions. It is important to understand that all functions are objects in JavaScript. They all encapsulate a bit of reusable code.

In most languages, including Ruby, these functions are called classes, but in JavaScript you have constructor functions.

1
2
3
4
5

// Constructor Function
function Person (name, favoriteLanguage) {}

// Particular instance of constructor function instantiated. 
var Amber = new Person("Amber", "JavaScript");

Now Amber is an object created from the Person object. The biggest advantage to using a constructor function over the basic hash above is that you can now reuse the Person function over and over again. You can give the Person function properties and methods, and those will be copied over to every instance of that object.

The constructor function can now have properties:

1
2
3
4
5
6
7
8
9
10
11
12
13

// Constructor Function
function Person (name, favoriteLanguage) {
  this.name = name;
  this.favoriteLanguage = favoriteLanguage;
  this.changeName = function(newName){
    this.name = newName;
  }
}

// Particular instance of constructor function instantiated. 
var Amber = new Person("Amber", "JavaScript");
Amber.name //=> "Amber"
Amber.changeName("Bethany") //=> Amber.name => "Bethany"

If you have a group of methods that you want every instance of the constructor function to inherit, you can also encapsulate those methods in a prototype.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

// Constructor Function
function Person (name, favoriteLanguage) {
  this.name = name;
  this.favoriteLanguage = favoriteLanguage;
}

// Prototype 
Person.prototype = {
  constructor: Person,
  changeName: function(newName){
    this.name = newName;
  }
}

//OR 

Person.prototype.constructor = Person;
Person.prototype.changeName = function(newName){
    this.name = newName;
}

When you add functions to a prototype, they are only created once. And then everytime an instance calls one of those methods, the instance refers to the one created in the prototype.

If you add functions to the constructor, they are duplicated every time you create a new instance of the constructor when is less efficient and consumes more memory.

However, one plus to creating methods inside the constructor function is that those functions have access to private data (i.e. they are privileged), whereas functions in prototypes are not.

Call vs Apply

If you would like to scope a function to an object, you can use the methods call and apply. For example, if you take the changeName function outside of the prototype in the sample above.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

  function Person (name) {
    this.name = name;
  }
  var Amber = new Person("Amber");

   var changeName = function(newName){
      this.name = newName;
    }

  /* Calling changeName() here will result in 'undefined' 
  because it doesn't know the scope of this. 
  You can bind a scope to a function with the call method. */

  // changeName.call(scope, arguments)

  changeName.call(Amber, "Bethany");
  Amber.name //=> "Bethany"

  /* This binds the function to the Amber object 
  and passes it the argument "Bethany". */

apply is very similar to call, except you pass it arguments as an array and it can take an unknown amount of arguments.

1

  changeName.apply(Amber, ["Bethany"])

There are many intricacies I have not discussed here, but I hope this post gives you a taste of JavaScript and some of its basic concepts and quirks.

Insertion Sort works by iterating up the current array, placing the current element into the correct place in the new sorted array.

1. First, take the first element of the unsorted array out of the array and put it into an empty new array.
2. Take the next element out of the unsorted array and place it into the new array. If it is smaller than the first element in the new array, swap them. If not, leave it at the end.
3. Take the next element out of the array and put it at the end of the new array. If it is larger than the previous end element, leave it. If not, iterate through the array until you find its correct position and insert it there.
4. Continue this process until your original array is empty and you have a new completely sorted array.

While more efficent than Bubble Sort, Insertion Sort still has the same average and worse case time complexity of O(n²). Like Bubble Sort, it is very inefficient for large data sets, but rather efficient for small data sets or data sets already mostly sorted (the best case time complexity is O(n)).

Implementation of Insertion Sort in Ruby.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

class InsertionSort

  def initialize(array)
    @array = array
    @sorted_array = []
  end

  def sort
    j = 0
    while @array.length > 0
      @sorted_array << @array.shift
      if @sorted_array.length > 1 && @sorted_array[j-1] > @sorted_array[j]
        @sorted_array.each.with_index do |n, i|
          if @sorted_array[i] > @sorted_array[-1]
            @sorted_array[i], @sorted_array[-1] = @sorted_array[-1], @sorted_array[i]
          end
          if (@sorted_array[i] <  @sorted_array[-1]) && (@sorted_array[i+1] > @sorted_array[-1])
            @sorted_array.insert(i+1, @sorted_array[-1])
            @sorted_array.slice!(-1)
          end
        end
      end
      j+=1
    end
    @sorted_array
  end
end

print InsertionSort.new([4,1,6,3,5,2]).sort #=> [1, 2, 3, 4, 5, 6]

And in JavaScript:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

function insertionSort(array) {
    var sortedArray = [];

    for (var i = 0; i < array.length; i++) {

        sortedArray.push(array[i]);
        var len = sortedArray.length;

        if ((len > 1) && (sortedArray[len - 1] < sortedArray[len - 2])) {
            for (var j = 0; j < len; j++) {
                if ((len === 2) && (sortedArray[j] > sortedArray[len - 1]))
                {
                    var first = sortedArray[j];
                    var second = sortedArray[len - 1];

                    sortedArray[j] = second;
                    sortedArray[len - 1] = first;
                }
                else if ((sortedArray[j] <= sortedArray[len - 1])
                && (sortedArray[len - 1] <= sortedArray[j + 1]))
                {
                    //Insert the new element where it belongs.
                    sortedArray.splice(j + 1, 0, sortedArray[len - 1]);
                    // Delete it from the end of the array.
                    sortedArray.splice(sortedArray.length - 1, 1);
                }
            }
        }
    }
    return sortedArray;

}

insertionSort([4, 1, 2, 6, 3, 5]); //=> [1, 2, 3, 4, 5, 6]

This is the second post in a series of posts on various sorting algorithms in computer science. See the entire series here.

We’ll start with Bubble Sort.

Bubble Sort is a simple sorting algorithm.

1. You start by comparing the first two items in an array. If the first item is larger than the second, you swap the two items.
2. Then, you compare the second and third items. If the second is larger than the third, you swap them.
3. Continue until you reach the end of the array.
4. Then, you start from the beginning again and repeat the process until you have one full pass of the array in which you did not swap any items.
5. You now have a sorted array!

The name ‘bubble sort’ derives from the event of the smaller numbers slowly ‘bubbling’ to the front of the array through the swapping process.

Here’s the bubble sort algorithm implemented in Ruby.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

class BubbleSort

  def initialize(array)
    @array = array
  end

  def sort
    loop do
      i = 1
      swap_number = 0
       while i < @array.length
         if @array[i-1] > @array[i]
          @array[i-1], @array[i] = @array[i], @array[i-1]
          swap_number += 1
         end
         i+=1
       end
      break if swap_number == 0
    end
    return @array
  end

end

print BubbleSort.new([4,1,2,6,3,5]).sort #=> [1, 2, 3, 4, 5, 6]

And, here’s it in JavaScript.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

function bubbleSort(array) {
    var swapNum;

    while (swapNum !== 0) {
        swapNum = 0;
        for (var i = 0; i < array.length; i++) {
            if (array[i] > array[i + 1]) {

                var first = array[i];
                var second = array[i+1];

                array[i] = second;
                array[i+1] = first;

                swapNum++;
            }
        }

    }
    return array;
}

bubbleSort([4,1,2,6,3,5]); //=> [1, 2, 3, 4, 5, 6]

One of the biggest problems with using bubble sort is that it isn’t practical on large data sets. It is incredibly inefficient with an average and worst-case time complexity of О(n²).

In the best-case where the array is already sorted, the time complexity is O(n) because it only has to do one pass of the array, whereas most other algorithms still have to go through all their steps even when given an already-sorted array.

That being said, bubble sort is still a very undesirable and inefficient sorting technique.

This is the first post in a series of posts on various sorting algorithms in computer science. See the entire series here.

Writing view templates using ERB, the default Rails templating language, has always seemed unnecessarily messy to me. ERB tags do not flow well with Ruby code or HTML tags. They are time-consuming to write in code. You also cannot use the command-slash commenting shortcut in Sublime Text with them; you must comment out each line of Ruby code separately (which makes them even more time-consuming to maintain).

Therefore, I was delighted when I discovered HAML (HTML abstraction markup language). A markup language that was designed to replace messy ERB templates with simpler, cleaner design. Why? Because markup should be beautiful.

While this idea may seem crazy to certain people, just take a look at the following basic forms, one written in basic HTML and one in HAML.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

<%= form_for(@post) do |f| %>

  <div class="field">
    <%= f.label :name %>
    <%= f.text_field :name %>
    <%= f.label :content %>
    <%= f.text_area :content %>
  </div>

  <div class="field">
    <%= f.collection_check_boxes :tag_ids, Tag.all, :id, :name %>
  </div>

  <div class="field">
    <%= f.fields_for :tags, Tag.new do |tag_form| %>
      <%= tag_form.label :name, "Name" %>
      <%= tag_form.text_field :name  %>
    <% end %>
  </div>

  <div class="actions">
    <%= f.submit %>
  </div>

<% end %>

Here is the same exact form using HAML instead of ERB:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

= form_for(@post) do |f|
  .field
    = f.label :name
    = f.text_field :name
    = f.label :content
    = f.text_area :content
  .field
    = f.collection_check_boxes :tag_ids, Tag.all, :id, :name
  .field
    = f.fields_for :tags, Tag.new do |tag_form|
      = tag_form.label :name, "Name"
      = tag_form.text_field :name
  .actions
    = f.submit

That’s 44 percent fewer lines of code, with a cleaner and more elegant design that also took less time to write. You can also comment out the entire section with one command, if desired. (No more commenting out individual ERB lines again!)

major pros

Elegance.

It’s shorter, cleaner, and way more beautiful than HTML.

Faster.

No more time wasted writing those useless closing tags! No more time wasted commenting out separate lines of code! Allows developers to produce awesome projects faster.

Closely related to CSS.

Your HTML code becomes more clearly associated with its CSS. Most useless HTML tags are gone, leaving simply the CSS relationships.

Whitespace sensitive.

Everybody must have the same indentations and code form. This will force coders to adhere to standard practices, guaranteeing that others will be able to easily read their code.

major cons

Whitespace sensitive.

You have to be extra careful with how you indent and write your code. This can be particularly frustrating for some people who would prefer not to have to follow a certain indentation practice or have to worry about whitespace. It can also be extremely hard to debug, since it’s not always obvious if there’s an extra whitespace in your code since you can’t see it!

Processing speed.

According to this person, HAML has a slightly slower processing speed than ERB (and SLIM, another markup language focusing on elegant design.)

Cost of change.

Most people know HTML. Most people do not know HAML. It takes a bit of time to learn, when you can do the same things in HTML that you can do in HAML.

change can be frustrating

…but it doesn’t have to be!

Fortunately, if you do want to use HAML on a project going forward, there are handy websites like Html2Haml that will instantly convert ERB templates to HAML, hassle-free.

Just make sure you gem install haml and require HAML in your project.

You can also create a new Rails app that uses HAML automatically with this command:

rails new myapp -m https://raw.github.com/RailsApps/rails-composer/master/composer.rb

After you run this command, you will be prompted for several preferences, including templating engine. Then, you can select ERB, HAML, or SLIM. If you choose HAML, it will automatically create your view files with the .html.haml extension.

Now go and produce prettier code with HAML!

Additional Resources:

By accessing the data through the method call, you are protecting the data from being accessed directly. Therefore, if the data changes unexpectedly, you will only have to adjust the one method. If you access the data directly throughout your code, you may have to change it many times so that your code doesn’t break.

It is a fine distinction, but can become an incredibly important one the larger your program is.

Here’s an example. Let’s set up a basic class to get us started.

1
2
3
4
5
6
7
8

class Cat

  def initialize(name, age)
    @name = name
    @age = age
  end

end

This Cat class can be initialized with two variables: @name and @age.

Now, let’s make our class more interesting.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

class Cat

  def initialize(name, age)
    @name = name
    @age = age
  end

  def age_in_human_years
    if @age == 0
      @human_age = 0
    elsif @age == 1
      @human_age = 15
    else
      @human_age = 16 + @age * 4
    end
  end

end

Now, we have a method that accesses the @age instance variable that is initialized upon instantiation. By using ‘@’ instead of ‘self’, we are directly accessing that variable.

But, what if we wanted a variable that actually equals age + 2? We could add in that variable and use it throughout. Like so:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

class Cat

  def initialize(name, age)
    @name = name
    @age = age
    @new_age = age + 2 #=> addition
  end

  def age_in_human_years
    if @new_age == 0 #=> change 1
      @human_age = 0
    elsif @new_age == 1 #=> change 2
      @human_age = 15
    else
      @human_age = 16 + @new_age * 4 #=> change 3 
    end
  end

end

One could argue that we could’ve just initialized @age to be equal to age+2, but I think that would go against Ruby convention and confuse matters. Plus, we could then never access both age and age+2. @age would be stuck at age + 2.

Okay, we made those changes. That wasn’t too hard. However, what if we referenced this variable in a thousand different places? It just wouldn’t be feasible or desirable to have to comb through the code and change them all.

Here’s where self comes in. Let’s go back one step and reimplement the example with self.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

class Cat

  attr_reader :age

  def initialize(name, age)
    @name = name
    @age = age
  end

  def age_in_human_years
    if self.age == 0
      @human_age = 0
    elsif self.age == 1
      @human_age = 15
    else
      @human_age = 16 + self.age * 4
    end
  end

end

So, we changed the @age to self.age throughout. And, added in a attr_reader, which is shorthand for this method:

1
2
3

  def age
    @age
  end

It merely creates a method that can access the instance variable. So, to clarify, when we reference @age we are accessing the variable data directly. But, when we use self.age (note: the ‘self’ is actually optional), we are accessing the variable indirectly through this reader method.

So, again, say we want to make that age adjustment and add 2 to the given age. Instead of adjusting the code accordingly, we can just create our own reader method for that variable.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

class Cat

  def age
    @age + 2
  end

  def initialize(name, age)
    @name = name
    @age = age
  end

  def age_in_human_years
    if self.age == 0
      @human_age = 0
    elsif self.age == 1
      @human_age = 15
    else
      @human_age = 16 + self.age * 4
    end
  end

end

The only thing we did this time for that change is delete the default attr_reader method and define a short method that changes the information received when one calls .age. Also, this way, we can preserve access to the original given age, by calling @age, and we can access @age+2, by calling .age.

The difference may seem insignificant. And, in small programs, it probably is. But, as programs grow larger, this may make a significant difference in how costly one change may be.If you are only directly accessing the data of an instance variable in one place, you only have to change it in one place. But, if you are directly accessing it hundreds of times, you may have to look at all of those pieces to verify that they won’t break now that the value of a variable has changed.

So, the take-away: always hide data from yourself. It is the best defensive strategy to protect your code from unexpected changes.

Additional Resources:

In this post, I plan to discuss hidden Ruby tricks that many beginning Rubyists might not know about (yet!) that I’ve discovered online or through playing around with Ruby. This is by no means a comprehensive list, but I hope it illustrates a few of Ruby’s awesome tricks. They are all included in the Ruby Documentation if you want to learn more. Also, shout out in the comments if you know of any other good ones to add to the list!

.collect.with_index

This one may seem obvious to most, but it was a happy discovery for me last week when I was trying to solve a problem. I had been familiar with the method .each.with_index for a while, and every time I needed to use indexes while iterating, I used it. However, I prefer .collect over .each in most cases, and was frustrated that I couldn’t use indexes with collect. I’m not sure why I thought it could only work with .each, but I did for a while. But then I tried it with .collect, and it worked! .collect.with_index is a real thing! So, the method .with_index can work on either .each or .collect.

In general, .collect is preferable to .each in any iteration where you are trying to collect data from a block into a new array. The code written with .collect will be cleaner and more concise, as shown in the example below.

1
2
3
4
5

array = [1,2,3,4]

new_array = Array.new
array.each.with_index {|num, index| new_array << num * index }
new_array #=> [0,2,6,12]

1
2
3
4

array = [1,2,3,4]

new_array = array.collect.with_index {|num, index| num * index}
new_array #=> [0,2,6,12]

.freeze

Freeze! Because this is Ruby, the method .freeze does exactly what you think it does. It freezes the object from being altered in any way. And you can even check if an object is frozen by asking it if it’s frozen! This may be useful if you have a class that you want to alter in your program until a certain condition is met, then if you want the object to be immutable you can just .freeze it from that point on.

1
2
3
4
5
6

array = [1,2,3]
array.freeze
array.collect! {|num| num * 27}
  #=> "RuntimeError: can't modify frozen Array"
array.frozen?
  #=> true 

.to_s(base)

This was a cool discovery for me. If you convert an integer to a string (using .to_s), it can take an argument that will convert it to a different base. It works up to base 36.

1
2
3
4
5
6
7
8

#2 in binary
2.to_s(2) #=> "10"

#converting to binary
5678437.to_s(2) #=> "10101101010010101100101"

#converting to base 23
5678437.to_s(23) #=> "k6g6d"

Splat * symbol

Splat(*) is very cool and powerful. Here’s a few splat tricks I’ve learned.

allows an array to take unspecified amount of arguments

It allows an array to take any number of arguments, and returns those values in a array. You can use it with other aguments, if you want to separate the first or last argument from the array.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#splat argument as the only arugment 
def splat_is_awesome(*a)
  a
end

splat_is_awesome("and","it","looks","cool","too")
 #=> ["and", "it", "looks", "cool", "too"] 

#splat as last argument
def splat_power(a,*b)
  [a,b]
end

splat_power("powerful","stuff","here")
 #=> ["powerful", ["stuff", "here"]] 

#splat as first argument
def splat_power_reversed(*a,b)
  [a,b]
end

splat_power_reversed("powerful","stuff","here")
 #=> [["powerful", "stuff"], "here"] 

converts 1D array to a hash

I think this is the kind of thing that doesn’t seem very useful until you get that one rare type of problem where it ends up being perfect for. If you use splat * on an array as the key in a new Hash, it will automatically split the array into key-value pairs and then create the new hash. Note that it only works when you have an array with an even number of elements.

1
2
3
4
5
6
7

animals = ["cat","meow","snake","hiss"]
Hash[*animals] #=> {"cat"=>"meow", "snake"=>"hiss"} 

#It first splits the elements into pairs and then creates the Hash: 
# ["cat","meow","snake","hiss"] ==> 
# ["cat"=>"meow","snake"=>"hiss"] ==> 
# {"cat"=>"meow", "snake"=>"hiss"}  

Ruby Documentation

Use the documentation! It’s the best resource you have. If you want to know what a method does, it will almost always say it in the documentation. If not, the method probably doesn’t exist. (But sometimes it does.) Despite that: Use. The. Documentation.

IRB

For weeks before Flatiron, I was beginning to learn Ruby. And when I wanted to know what a Ruby method did, I would often open up another ruby doc in a text editor and then puts the result to the terminal. Then, on the first day of class, I learned about IRB! IRB stands for “interactive ruby,” and is a tool that interactively executes Ruby code in the terminal. Just key in “irb” and Ruby away! Now, every time I’m unsure of a piece of code, I simply check it in irb! Such a time-saver!

Pry

Also extremely useful is the RubyGem Pry. Unlike IRB which is great to check a basic piece of syntax, Pry can actually be run in your program and will tell you what piece of information it receives every step of the way. It’s crazy useful, and if you are a Ruby developer, an absolute must in debugging.

Rubular.com

If you know anything about Ruby, you’ll know about Regular Expressions (aka “Regex”). And if you know anything about Ruby, I’m sure you have a love-hate relationship with them. Ruby is fondly know as being fairly English-y and intuitive, but I don’t really consider things that look like this English:

/\A[a-z]+.*[a-z]*@{1}[a-z]+.[a-z]+.*[a-z]*\z/

Regexs are extremely powerful in Ruby, because they let you manipulate data in a very complicated yet precise way. But, often they are long and cumbersome. Enter Rubular! In Rubular, you can build your regexs interactively with the data you are trying to manipulate, and conversely, immediately determine what data an already-constructed regex is trying to gather. It’s truly priceless for a dedicated Rubyist.