You could probably spend your whole life building Rails apps and never need to use any bitwise operators. If you're new to programming, you may not even know what "bitwise" means.
But the moment you take an interest in systems where efficiency is important and resources are limited, bitwise operations become crucial. They're used extensively with things like networks protocols, cryptography, Unix files permissions and embedded systems.
In addition, to really understand how the computer does things like add two numbers, you have to understand bitwise operations.
Since Ruby and many other languages have native support, they're a great tool to add to your toolbox, even if it's only to understand what's going on if you encounter them in the future.
In this article, we'll cover what bitwise operations are, some examples of where they can be applied and how we can best use them in Ruby. Let's begin.
What are bitwise operations?
At the lowest level in any computer, we only have 1s and 0s, also known as bits. Any other operation that we use in Ruby or any other programming language is eventually stored as 1s and 0s, but the software in our computers transforms them effectively back and forth between what we see and what's actually stored. For example, we store the string "hello" as a chain of 1s and 0s.
Bitwise operations allow us to access directly those bits, usually representing numbers, and do "something" with them. Some operations will help us in implementing features in our software in a more elegant and efficient way.
There are two important aspects to highlight about bitwise operations for now: they're extremely effective in storing information, since we're using bits directly, and they're very fast in execution.
The basic behavior is having a set of bits and applying the operator to it. You can also use the operators with two sets of bits. Let's see some operations:
NOT bitwise operation
This is a unary operation, which means that it only applies to a set of bits and it's as simple as replacing the 1s with 0s and vice versa. It's represented with the symbol:
~101000 = 010111
AND bitwise operation
AND is an operation that applies to two sets of bits; its symbol is
& and it follows this logic:
1 & 1 = 1 1 & 0 = 0 0 & 1 = 0 0 & 0 = 0
So when we have two equal-length sets of bits, the result is just applying this logic to each individual pair:
0110 AND 0111 ----- 0110
25.to_s(2) # 11001 30.to_s(2) # 11110 (25 & 30).to_s(2) # 11000
OR bitwise operation
Similar to the AND operation, another operation that also applies to two sets of bits is the bitwise OR. Its symbol is
| and follows this logic:
1 | 1 = 1 1 | 0 = 1 0 | 1 = 1 0 | 0 = 0
So if we have 1 on either side, the result is 1, otherwise it's 0. Very simple! Let's see an OR operation with more bits:
0110 OR 0111 ----- 0111
And in Ruby:
25.to_s(2) # 11001 30.to_s(2) # 11110 (25 | 30).to_s(2) # 11111
Practical example 1: Permissions
At this point, you might be wondering why these operations are useful. After all, they seem pretty low-level. You may not have any plans to work directly with network protocols, graphics or cryptography.
But you've probably worked with permissions before. Permissions are one area where bitwise operations can be really useful. Imagine you have a permissions system where users can perform different actions in a document:
- Invite other users
And now we want to model these actions into different roles:
- Assistant: can view and edit the document.
- Observer: can only view the document.
- Author: can perform all actions.
How could we model this? How do we know at any point if a user has one of these roles? One answer is to use bitwise operations.
We'd store only one set of bits for each user that represents the permissions they have:
(Starting from the right side) 1st bit: View 2nd bit: Edit 3rd bit: Delete 4th bit: Invite other users
0001 = Can only view the document. 0011 = Can view and edit the document. 1001 = Can view, can't edit, can't delete and can invite others.
Once we have these values set for some users, we could do some really fast comparisons with the permission we want. Let's imagine we're checking if a user can edit the document. We could use a bitwise AND operation:
# This is called a bit mask. It contains only the value we want to check, in this case the second bit for editing. EDIT_PERMISSION_MASK = 0b0010 # We can define a quick method to check this: def can_edit_document?(user_permisions) (EDIT_PERMISSION_MASK & user_permisions) != 0 end
This means that if the bitwise AND operation gives us something different than 0, we have that bit set:
0010 AND 1101 ---- 0000 == 0 so we don't have the permission 0010 AND 1110 ---- 0010 != 0 so we have the permission
We could apply the same logic to any other permission by modifying the position of the bit that we want to check, so we'd end up with these constant and the corresponding methods:
VIEW_PERMISSION_MASK = 0b0001 EDIT_PERMISSION_MASK = 0b0010 DELETE_PERMISSION_MASK = 0b0100 INVITE_PERMISSION_MASK = 0b1000
In addition, we can dynamically define the permissions and store new permissions in the future with a quick bit check.
For example, we said earlier that an assistant can only view and edit the document, so the permissions for that user would be:
0011. We can store that value in our database and then we can easily check if an assistant can perform an action with the methods defined earlier.
ASSISTANT_MASK = VIEW_PERMISSION_MASK | EDIT_PERMISSION_MASK # This will be: 0011 # Optionally, we could use this method to check if this user is an assistant. This method could be defined inside the User class. def is_assistant?(user) (user.permissions == ASSISTANT_MASK) end
If all of this sounds familiar, that's because it's the same approach that is commonly used for file permissions in Unix-based systems.
Practical example 2: Positions in a team
Let's use bitwise operations a bit more 😉.
We can apply them in another case that's relatively common: different positions on a sports team or job positions in a company. Let's go with a basketball team to simplify.
In basketball, there are 5 positions when playing a game: - Point guard - Shooting guard - Small forward - Power forward - Center
And we can assign a set of bits to each position:
00001 Point guard
00010 Shooting guard
00100 Small forward
01000 Power forward
The same in Ruby would be:
POINT_GUARD_POSITION = 0b00001 SHOOTING_GUARD_POSITION = 0b00010 SMALL_FORWARD_POSITION = 0b00100 POWER_FORWARD_POSITION = 0b01000 CENTER_POSITION = 0b10000 POINT_GUARD_POSITION | SHOOTING_GUARD_POSITION | SMALL_FORWARD_POSITION | POWER_FORWARD_POSITION | CENTER_POSITION # = 31
So now we could do some interesting things, like check if the whole team is present with:
# p1...p5 are the positions of each player is_full_team_present = (p1 | p2 | p3 | p4 | p5 == 31)
Why? By doing the bitwise OR operation, if we had all the positions, we'd end up with: 11111.
# OR bitwise operation 00001 | 00010 | 00100 | 01000 | 10000 ----- 11111
And 11111 is 31, because 2^0 + 2^1 + 2^2 + 2^3 + 2^4 = 31.
This is not strictly related to bitwise operations, but with this data modeling we could also check if two players can be exchanged. This would be very simple:
def can_be_exchanged?(player1, player2) player1.position == player2.position end
Another operation we can do with two sets of bits is XOR, whose symbol is
XOR means exclusive OR and it follows this logic:
1 | 1 = 0 1 | 0 = 1 0 | 1 = 1 0 | 0 = 0
So the result will be 1 only if one of the two bits is 1; if both are equal it'll be 0.
This operation is used in some algorithms to compare a number to itself, since x ^ x = 0.
This is an interesting group of operations where we "move" bits to one side or the other within a set. Let me explain.
With a bit shift, we move or "shift" the bits in one direction, left or right:
00010111 left-shift <------- 00101110
10010111 right-shift -------> 11001011
We can move or shift bits n times. Here's a left shift applied to the number 5 twice in Ruby:
5.to_s(2) # 101 (5 << 2).to_s(2) # 10100
As you can see, a left shift is represented by <<. A right shift uses >>:
5.to_s(2) # 101 (5 >> 2).to_s(2) # 1
In this case, we only get one, because the bits "0" and "1" from 1*01* have been discarded.
Divide by 2 with right shift
One interesting fact about bit shifts is that you can computate some mathematical operations with them. In the past, this was faster, but nowadays this is almost exclusively used by programmers who work with more constraints in resources like in game development.
If we apply a right shift to a number, we get the result of dividing it by 2:
10.to_s(2) # 1010 (10 >> 1).to_s(2) # 101 10 >> 1 # 5
Multiply by 2 with left shift
In the same fashion, we can multiply by 2 with a left shift:
10.to_s(2) # 1010 (10 << 1).to_s(2) # 10100 10 << 1 # 20
Quickly check if a number is odd or even
There's a very simple example of a bitwise operation that's really fast and easy to follow.
Imagine we do an AND operation with 1, just 1. So that'd be any number of 0s, depending on the computer we're in, and 1. Let's do it with 2:
2 = 00000010 & 00000001 ------------- 00000000
Now with 4:
4 = 00000100 & 00000001 ------------- 00000000
What about 5?
5 = 00000101 & 00000001 ------------- 00000001
Now we got 1. Can you guess what this means?
By doing this AND with 1, if the number is even, we'll get 0. If it's odd, we'd get 1. We could easily use this fact to create a couple of methods in Ruby:
def is_odd?(number) number & 1 end
def is_even?(number) is_odd?(number) == 0 end # Or: def is_even?(number) (number & 1) == 0 end
If you want to go further, or experience some mind-blowing moments with bits, check out this bitwise hacks collection for more tricks.
Bitwise operations are hard to follow if you've never encountered them, but once you're familiar with them you'll be better prepared to deal with existing or future projects that use them. Plus, you'll have a new tool when planning a solution for a problem in your code.