Ruby VS Python VS C++ VS JavaScript
Tags: ruby, python, javascript, cpp
Published: 2021-02-22 05:06:32

---
title: Ruby VS Python VS C++ VS JavaScript
published: true
description: My experience programming languages and a little race between a few of them
tags: ruby, python, javascript, cpp
cover_image: https://dev-to-uploads.s3.amazonaws.com/uploads/articles/48w2cshlkpuwcm19pdh1.png
---
## Why Ruby?
When I initially started learning Ruby, I read a lot of articles talking about the problems with Ruby. "It's a dead language." "Nobody uses Ruby anymore." "Just learn Python. It's faster anyways." While these comments didn't hinder me at all, they did make me question the reason for learning Ruby: why didn't my bootcamp choose a faster more popular language that was still beginner friendly like Python? Needless to say, I still attended the bootcamp and learned Ruby, and I am so happy I did.

## In The Beginning There Was C, + More 
Although I never graduated university (life has a habit of getting busy), I did work towards a software engineering degree. My university, I'm sure like many others', introduced programming with one of the more unforgiving languages, C++. I remember not even worrying about the language: I didn't know the difference between compiled and interpreted languages. Weird syntax? Yeah, that's just programming. Things got difficult when I started my second semester computer science course. We were writing games and dynamic memory allocation didn't come naturally to me.

## Bootcamp
After I dropped out I spent some time learning HTML, CSS, and then JavaScript. Thankfully, JavaScript has a lot of similarities with C++ when it comes to syntax. Sure types aren't a thing (I know they can be #TypeScript), but I felt fine with the loops and conditional statements, and I sure do love semicolons. In 2020 I decided to take a leap of faith and applied for Flatiron School's software engineering program. The curriculum would include JavaScript, Ruby, React, and Rails. I was very excited to learn how to build real-world applications. My first project was using an API to make a CLI application, and it was so great to finally understand what an API was. 

## The Saving Gem
When I started learning Ruby, I didn't think much of the differences between it, JavaScript or C++. Sure, **end**ing blocks of code instead of using curly brackets was strange and leaving out parentheses was not something I did. Honestly, I still coded very much in the C++ way my university taught me: for/while loops, the parentheses, etc. But then something wonderful happened. I learned about enumerables. A beautiful chord was struck. I could easily alter data with a few simple lines of code. I could check if every element in an array was even with `.all?`. I could easily see if I had a user with the name **Voltron** with `.any?`. I could even change every element in an array to the same thing with `.collect`. I started to the see the beauty of doing things the Ruby way.

## The Epiphany
After diving deep into JavaScript and learning about higher-order functions, I realized other languages could do similar things to Ruby. `.forEach` and `.map` for `.each` and `.map`. Even after realizing this I still felt Ruby was more magical. Maybe I felt this way because I could simply express what I wanted the computer to do with fewer lines of code. Maybe Ruby was my first real language. Regardless of why, I was a Rubyist.
 
## Again... Why Ruby?
Fast forward to present day post graduation: the job search. Searching for and applying to jobs for months I have realized that while definitely not a dead language and still highly in demand, Ruby is not the most sought after language. And most of the time teams that *are* looking for Ruby/Rails devs are looking for senior engineers. I needed to adapt and broaden my skills. I decided that while I would continue perfecting my Ruby skills and make apps with Rails and JavaScript, I would also learn a new language: Python.

## Easy Right?
I made this decision mostly based on the fact that I have seen Python used in multiple FOSS project, and I had heard it was easy to automate tasks using the language. I started learning using "[Automate the Boring Stuff"](https://automatetheboringstuff.com/). I hadn't gotten very far in when I decided that Python wasn't right for me. Too many colons, no visual ending to block of code besides the lack of white space, and don't get me started on needing to type exit() vs just exit in the Python Interpreter. Ruby had spoiled me. In my moment of contempt for such a foul looking language I decided to see if Python was indeed faster than Ruby! Surely Ruby 3.0.0 would give the "two snakes" a run for their money.
 
## The Race
Initially I wanted to see how fast the languages could loop through a range and do some calculations while printing the answers. Interestingly enough I learned that Ruby's `print` is much faster than its `puts` and Python's `print()` beats Ruby's `puts` but not its `print` (I threw in JavaScript and yikes console.log is really really slow). Printing probably isn't a good indicator of anything, so I decided I needed some random number generation and some conditional statement to execute on a large range of numbers multiple times. Here's the finished solution in both languages plus JavaScript and C++ just for fun:
### Ruby
```ruby
def do_the_thing(num)
  success = []
  no_success = []
  while num > 0
    if rand(num) >= num - 10
      success.push(num)
    else
      no_success.push(num)
    end
    num -= 1
  end
  return success.size
end
sum = 0
100.times do
  sum += do_the_thing(1000000)
end
puts sum
```

### Python
```python
import random
def do_the_thing(num):
    success = []
    no_success = []
    while num > 0:
        if random.randint(1, num) >= num - 10:
            success.append(num)
        else:
            no_success.append(num)
        num -= 1
    return len(success)
sum = 0
for x in range(1, 100):
    sum += do_the_thing(1000000)
print(sum)
```

### C++
```cpp
#include <iostream>
#include <vector>
#include <ctime>
using namespace std;

int doTheThing(int num)
{
	srand(time(NULL));
	vector < int > success;
	vector < int > noSuccess;
	while(num > 0) 
	{
		if((rand() % num + 1) >= num - 10)
		{
			success.push_back(num);
		}
		else
		{
			noSuccess.push_back(num);
		}
		num--;
	}
	return success.size();
}

int main()
{
	int sum = 0;
	for(int i = 0; i <= 100; i++)
	{
		sum += doTheThing(1000000);
	}
	cout << sum << endl;
	return 0;
}
```

### JavaScript
```js
function doTheThing(num) {
	let success = [];
	let noSuccess = [];
	while (num > 0) {
		if((Math.floor(Math.random() * Math.floor(num))) >= num - 10) {
			success.push(num);
		} else {
			noSuccess.push(num);
		}
		num -= 1;
	}
	return success.length;
}

let sum = 0;
for(let i = 0; i <= 100; i++) {
	sum += doTheThing(1000000);
}
console.log(sum)
```

## The Results
Thanks to Linux's `time` command, I was able to time how long a given command would take (I used node for the JS and I combined the compilation time and run time for C++).

| language | real time | command                          |
|----------|-----------|----------------------------------|
| ruby     | 0m21.568s | time ruby random.rb              |
| python   | 1m34.050s | time python3 rand.py             |
| js       | 0m04.290s | time node random.js              |
| c++      | 0m03.527s | time g++ random.cpp + time a.out |

JavaScript definitely surprised me the most with how speedy quick it was, and I didn't think Python would be as slow as it was. It might have something to do with including that random module (I had to change the name of the file to rand because the interpreter didn't like the file having the same name as the module).

## The Real Results
Ultimately I know every programming language has its pros and cons and obviously generating a random number isn't the best benchmark for a language. But I definitely had fun writing the same code in 4 different languages and writing C++ was an especially exciting trip down memory lane. It's fun knowing that each language has it's own quirks and seeing C++ after learning Ruby and JS and a little bit of Python was very eye-opening. I highly recommend learning another language once you've got your first one down solid. You will learn different ways of doing things and if one thing is certain it is that we should always be learning in this industry!