DEV Community: Samuel O'Daniels

Interesting JavaScript Features from a Ruby Perspective

Samuel O'Daniels — Sat, 10 Jun 2023 22:05:06 +0000

Hi there. I recently began relearning JavaScript, as it had been a year since I last did anything meaningful with it. So, I thought to share some of the differences that stood out to me as a Ruby developer. There should be a part 2, so you might want to watch out for that if you find this one entertaining.
Enough said. Let's jump right to the first difference.

No Error for Calling an Undefined Property

This tripped me up at first, but what's really happening is that classes in JavaScript are basically templates for creating Objects (hashes in Ruby). So, what looks like a "method" call (if you're coming from Ruby) is actually just accessing the property, including accessor properties like getters and setters, using dot notation. JS methods still need the () to be invoked.
Whereas in Ruby, any information you want from an object must be gotten through a method call. I'll attempt an example.

// JavaScript Class
class DemoClass {
    constructor() {
        this.codeName = 'You know who';
    }

    regularName = 'Unknown';
}

let target = new DemoClass;
console.log(target.codeName);
// => You know who
console.log(target['codeName']); // using brackets
// => You know who

Here, we can see that target is just a regular object (hash), and as a result, its properties can also be accessed using bracket notation, just like a hash in Ruby.

To access the same property in Ruby, we'll have to define a getter method that returns that property when called. target will be an instance of a real class, not a hash, so bracket notation won't work here. Also, I think referring to hashes as "objects" in JavaScript is just confusing, lol.

Optional Chaining

This dot notation for properties in JavaScript objects also affects the use of optional chaining (safe navigation in Ruby) because, depending on the usage, you will need less of the operator compared to Ruby.
Let's look at an example.
Say we have a user who, unbeknownst to us, doesn't have a currentAccount property, and we want to safely check their current account balance; this is how we can do that in JavaScript:

// ?. is the optional chaining operator in JS
user.currentAccount?.balance;
// => undefined

And in Ruby:

# &. is the safe navigation operator in Ruby
user&.current_account&.balance
# => nil

Notice that we had to use the operator twice in Ruby to avoid an error in case current_account was not a valid/defined method for the user object.

There's another difference when it comes to safely calling functions or methods. With JavaScript, ?. is placed between the function name and the parenthesis like so:

// supposing 'name' is undefined or null
user.name.toUpperCase?.();

In Ruby, the use appears more straightforward:

user&.name&.upcase
# even if you use parenthesis
# which you shouldn't use without arguments
user&.name()&.upcase()

Update: While testing the code examples for this section and the one before it, I made the mistake of "calling" JS functions as if they were properties. This created a hole in my understanding, causing me to make an inaccurate claim. Thankfully, u/jrochkind pointed it out on Reddit, so I made modifications to clarify the affected sections.

Accessing the Last Array Element

If you're coming from Ruby, you may instinctively try array[-1], but it'll return undefined. So, to actually get the last element in a JS array, you have to do:

array[array.length - 1];
// or less preferably
array.slice(-1)[0];

Using slice this way looks hacky, and you wouldn't be able to modify the element in place since it returns a new array.

With Ruby, however, you simply do:

array[-1]
# or to modify the element:
array[-1] = 'new last element'

Incrementing Numbers

Javascript has an increment (++) operator that you can use instead of doing something like num += 1 or num = num + 1.
However, Ruby does not have such an operator, so you have to use num += 1.

Function Parameters are Optional by Default

In JavaScript, missing arguments become undefined instead of raising an exception. Ruby, however, will raise an ArgumentError. Let's look at an example.
In JavaScript

// passing only one argument instead of two
function greet(timeOfDay, name) {
    return `Good ${timeOfDay}, ${name}`;
}

greet('morning');
// => Good morning, undefined

In Ruby:

def greet(time_of_day, name)
  "Good #{time_of_day}, #{name}"
end

greet('morning')
# => wrong number of arguments (given 1, expected 2) (ArgumentError)

No `none()` Even Though There's `every()`

JavaScript Arrays have every() and some() predicate methods, just like Array#all? and Array#any? in Ruby, but unlike JavaScript, Ruby Arrays have a #none? method, which is the opposite of #any?.
You might achieve a similar effect in JavaScript by either defining a none() function:

let none = (array, callback) => !array.some(callback);
// and use it like so
let arr = [1, 3, 4, 9, 15];
let result = none(arr, item => item > 20);
// => true

or simply negating the call like so:

arr = [1, 3, 4, 9, 15]
result = !array.some(item => item > 20);
// => true

In Ruby though, you write the same logic this way:

arr = [1, 3, 4, 9, 15]
result = arr.none? { |item| item > 20 }
# => true

Array.forEach() returns undefined

This might seem intuitive, and it probably is, but in Ruby, Array#each returns self, which is the object the method was called on. Here's an example.
In JavaScript:

const letters = ['a', 'b', 'c'];
result = letters.forEach((letter) => console.log(letter));
// result => undefined

In Ruby:

letters = ['a', 'b', 'c']
result = letters.each { |letter| puts letter }
# result => ['a', 'b', 'c']

Alright. That's the last one. I hope you found these rather interesting or insightful. Thanks for reading.
Until next time.

Upgrading Old Versions of Dokku

Samuel O'Daniels — Tue, 30 May 2023 15:02:33 +0000

Hi there. I originally planned to include this set of instructions as part of another article, but it was getting long. So I decided to make it into its own post. That said, let's jump right in.

If Dokku was automatically included for you through the Digital Ocean (DO) 1-Click Droplet, chances are you're running an inexcusably old version of the tool; version 0.21.4 specifically. It works fine for the most part, but there have since been dozens of releases with numerous improvements. The one improvement I'm particularly interested in is Cron support, because Dokku's Let's Encrypt plugin needs it to schedule cronjobs (tasks) for automatically renewing SSL certificates.

I spoke with the project's maintainer, and he submitted a PR to update DO's Droplet to use the latest version (0.30.6). He's also interested in automating the releases, so this shouldn't be an issue in the future. But in the meantime, we'll have to upgrade our versions ourselves.

Confirm The Version You've Got Installed

The upgrade path is dependent on the current version. Check it by running the following:

# on your dokku host
dokku version

If it's below 0.25.x, you'll have to first upgrade to 0.29.x before 0.30.x to avoid a breaking change. Conversely, you can go straight to the latest if you have a higher version.

Upgrade to Version 0.29.4

Stop all your running apps first using:

# on your dokku host
# for 0.22.0 and newer versions, use
dokku ps:stop --all

# for versions between 0.11.4 and 0.21.4, use
dokku ps:stopall

# for versions between 0.8.1 and 0.11.3, use
dokku --quiet apps:list | xargs -L1 dokku ps:stop

# for versions versions older than 0.8.1, use
dokku --quiet apps | xargs -L1 dokku ps:stop

Then run these two commands to upgrade.

# on your dokku host
# run the three commands one after the other
rm bootstrap.sh
wget https://raw.githubusercontent.com/dokku/dokku/v0.29.4/bootstrap.sh
sudo DOKKU_TAG=v0.29.4 bash bootstrap.sh

Upgrade to Version 0.30.6

Next, we'll upgrade to the latest version at the time of writing this article.

# on your dokku host
# run the three commands one after the other
rm bootstrap.sh
wget -NP . https://dokku.com/install/v0.30.6/bootstrap.sh
sudo DOKKU_TAG=v0.30.6 bash bootstrap.sh

Confirm the new version by running dokku version

Restart Apps

# on your dokku host
dokku ps:start --all

That's it. You're now on the latest version. If you visit this page in the future, you can find all the latest releases and their respective upgrade commands here.

Thanks for reading.
Till next time!

Adding a Domain and SSL Certificate to Your Dokku App

Samuel O'Daniels — Tue, 30 May 2023 14:56:35 +0000

In a previous article, we looked at how to host Rails apps on DigitalOcean with Dokku. But we used an IP address as the domain, and while that works all right, you'll need a domain you've bought if you want your app URLs to look professional. A domain name is also required for SSL, as certificate authorities like Let's Encrypt will not issue certs to IP addresses.

So, just as the title suggests, we'll add a domain and SSL cert to your app in the following steps.

Not Yet Deployed Your App?

No problem. Open the deployment article in a separate tab and return when you're done deploying to DigitalOcean.

Already Deployed Your App?

If you're using an IP address as the hostname, you'll have to add domains for Dokku.

Confirm by running this command:

# on your dokku host
# assuming app-name is 'ruby-getting-started'
# look at the value for 'Domains app vhosts:' in the output
dokku domains:report ruby-getting-started

If it's blank and Domain app enabled is false, run the following domain commands. Otherwise, skip to the DNS Section.

Add Global Domain

Run the following command to add your domain as the global domain:

# on your dokku host
dokku domains:add-global <example.com>

Add App Domain

Run the following to add the domain to the app:

# on your dokku host
# assuming 'ruby-getting-started' is your app's name
dokku domains:add <ruby-getting-started> <ruby-getting-started.example.com>

This will also configure the server to use the vhost to access the app.

You can confirm the domain of your app by running this command:

# on your dokku host
# assuming app-name is 'ruby-getting-started'
# look at the value for 'domains app vhosts:' in the output
dokku domains:report ruby-getting-started

All right! Let's proceed.

Create a DNS Record

Now that your app has been properly configured, you have to map your domain (or subdomain, in this case) to the IP address of your Dokku Droplet server.
I use NameCheap, but you can search for "how to add DNS record in <insert-your-domain-name-registrar" on Google.
It generally goes like this:

Log in to the dashboard of your domain name registrar and go to the advanced DNS settings for the domain you used earlier.
Add an A record with * as Host to catch all subdomains (*.example.com), and give it a value of your Droplet IP address. Set the TTL to automatic or 30 minutes and save the record.

See the table below for reference.

Type	Host	Value	TTL
'A' Record	*	123.111.22.3	Automatic or 30 minutes

Your ruby-getting-started.example.com domain should be functional after a minute or so.

Adding SSL

We'll be using Let's Encrypt because they provide free certificates, and there's an official Dokku plugin.

Install the dokku-letsencrypt plugin

run this command:

# on your dokku host
sudo dokku plugin:install https://github.com/dokku/dokku-letsencrypt.git

Set Global Let'sEncrypt Email

The plugin needs it to send you email reminders when certificates are about to expire. They expire in 90 days, but we'll address that soon.
Run this command to set the email globally so you don't have to do it on a per-app basis:

# on your dokku host
dokku letsencrypt:set --global email <your@email.com>

Enable Let's Encrypt for Your App

The command below will generate a certificate for your app's domain and configure the webserver to work with it.

# on your dokku host
dokku letsencrypt:enable ruby-getting-started

Reload your app's URL, and you should see a new security status symbol in the browser. Nice!

One More Thing

This certificate expires every 90 days, but thankfully, we don't have to always remember to update it. The dokku-letsencrypt plugin provides an option automatically update certicates that are due across all apps.

We May Have To Upgrade Dokku For This Part

The version of Dokku (0.21.4) currently installed on the 1-Click Droplet is very old and doesn't support Cron. I spoke with the project's maintainer, and he has submitted a PR to update it to the latest version (0.30.6).
To keep this section from getting too long, I've moved the upgrade guide to a separate article.

So, check your version by running the following:

# on your dokku host
dokku version

If it's below 0.3.x, upgrade your dokku install using the upgrade guide; otherwise, proceed.

Enable Automatic Certificate Renewal

Run this command:

# on your dokku host
dokku letsencrypt:cron-job --add

You should see an output like this:

root@dokku-demo-dp:~# dokku letsencrypt:cron-job --add
-----> Updated schedule file
-----> Added cron job to dokku's crontab.

Well done! Your site is now safe to use, and users will no longer get a warning from their browsers when they visit.
Thanks for reading. Until next time!

How to Take Advantage of the GitHub Student Developer Pack

Samuel O'Daniels — Fri, 12 May 2023 17:44:38 +0000

Nearly a decade ago, GitHub launched their Student Developer Pack. A valuable initiative to provide students with access to essential tools and high-quality paid resources to enhance their learning experience. If you're a student, this article aims to help you maximize the benefits offered through the program, ensuring you make the most of the available opportunities.

To access the offers available, start by visiting this page. Click on the register button and then click "get student benefits" to sign up for the pack. Verification requires your student email to confirm the message sent by GitHub. Once verified, you'll be able to access over 80 offers on the site.

While this article may mention Ruby or JavaScript, the resources cover many mainstream languages and stacks. So, without further ado, here's a curated list of standout offers.

Educative.io

With their offer, you get access to 60+ written programming courses on Educative.io for free. It used to be their entire library a few years ago, but you still get good courses despite the limited amount.

One piece of advice, though, especially if you're brand new to coding, is that it is beneficial to learn to set up your dev environment, and you won't learn that with Educative.io, as they have you code in their embedded IDE right there in the browser.
But you'll find great value in the courses once you account for that.

GoRails

A good way to learn to code is by reading and writing a lot of code. And GoRails helps you on the reading front, as you're essentially watching somebody build software. You'll notice certain interesting decisions and patterns, which can become options for you when building your own software.
GoRails has a lot of videos covering various aspects of Rails, and you get 12 months free plus an invite to their private Discord server.

DigitalOcean

Digital Ocean is a simple cloud hosting platform built for developers. I recently wrote a guide on how to host your Rails apps on there.
Once you claim your offer, you get $200 of free credit for a year, which should be enough to cover your hosting needs throughout its validity.

Namecheap and Name.com

Namecheap and Name.com are big-name domain registrars, and in partnership with GitHub, they each offer one free domain name registration and a free SSL certificate.

JetBrains

You've probably heard of IntelliJ. It's one of the most popular IDEs (not just among Java devs), and it was made by JetBrains. They have Development tools for whatever technology or platform you use, and their offer grants you access to all their IDEs (Including RubyMine and Webstorm) while you're a student.
Fun fact: they are the creators of the Kotlin programming language.

Frontend Masters

Frontend Masters has over 150 high-quality video courses from renowned Devs, including Sarah Drasner, Kyle Simpson (author of You Don’t Know JS), Brian Holt, and ThePrimeagen (the Vim evangelist, haha!).
You get all their courses for 6 months. Glad they haven’t nerfed their offer.

Despite what the name suggests, Frontend Masters also covers backend web development, DevOps, Linux & the command line, Machine Learning, Computer Science, Vim, and mobile app development.

Icons8

Icons8 provides photo, illustration, icon, and music assets for designers, and their offer nets you a 3-month, all-access subscription.

Replit

Replit is an online integrated development environment (IDE) that allows users to write, compile, and run code in various programming languages directly from their web browser. It provides a collaborative coding platform where multiple users can simultaneously work on the same project.

Their offer grants you private repls for 6 months.
If you want to see what your programs can look like on there, here is a chess game I wrote and hosted there last year. Although it's a CLI app, you can also run simple web apps there.

Interview Cake

Interview Cake is an online platform that offers resources and guidance for coding interviews, particularly for software engineering and technical roles. It provides a structured curriculum and practice materials to help individuals prepare for technical interviews at top tech companies.

It's pricey, but I've heard good things about it. You can get 3 weeks of access for free.

Dashlane

Dashlane is a top-rated password manager with loads of features. Here's an excellent review from PCMag
You can get 6 months of premium. Okay, that's not entirely true. You get all the premium features except the VPN, but it's good value nonetheless.

1Password

1Password is another popular password manager. I haven't used this one, but many people swear by it, so I'll include it.
You get 1 whole year of free access. Here's a review for good measure.

Mailgun

Mailgun is a cloud-based email service provider that offers email delivery and management solutions for businesses and developers. It provides a set of APIs that allow users to send, receive, and track email messages effortlessly.
You get 20,000 free emails and 100 free email validations each month for up to 12 months.

Phew! That's the last one.

Most of these services are worth the money, even if you're not a student. So, consider checking them out.

Alright! That's been it from me. If you think an offer should've made the list, let me know in the comments below.
Thanks for reading.

How To Deploy Your Rails App to a DigitalOcean Droplet Using Dokku

Samuel O'Daniels — Mon, 01 May 2023 01:26:32 +0000

Hi there, you're probably searching for a simple and cost-effective way to deploy your Rails app, especially now that Heroku no longer offers its free plan. Well, look no further. Dokku is an open-source Heroku alternative that simplifies deploying and managing our apps on a server. Combine that with DigitalOcean's affordable Droplets, and you've got an attractive solution.

For reference, you can deploy and run about three simple apps on one $6 droplet, but that's only about half the cost of hosting one app on Heroku with a database and caching. Moreover, unlike a Droplet, the Heroku server will sleep when it's not been accessed for a while. This is not to say that Heroku is overpriced. They do a lot of the work for you and charge more for the convenience.

Alright, before we proceed, what are "Droplets"? They are DigitalOcean's Linux-based virtual machines. When you create one, it becomes a server for your app(s).

Creating the Droplet

First, you need to sign up on DigitalOcean.

Next, head to the Dokku Droplet page and click the "Create Dokku Droplet" button to create a droplet with Dokku preinstalled. Note that if you create a regular droplet, you'll have to install Dokku manually, and more configuration will be required.
Select a region closest to you or your userbase on the create page for best performance. Select the "Basic" option and choose the $6/month plan under the "Regular" CPU option.
For authentication, choose SSH and click the button to add a "New SSH Key." You should see a pop-up like this

with instructions on how to get your SSH key from your device. Give your key a descriptive name. I like to use the name of my device (e.g., "M1 MacBook Air")

Scroll to the bottom and replace your droplet's hostname. A shorter name is ideal. You can use a name like "bootcamp-projects" or the app's name if the droplet is used exclusively for a single app. Create the droplet, which should take you to the project page, where you'll see your droplet with a loading progress bar. This indicates that your Droplet is being initialized. Once it's ready, you should see more details like this:

The series of numbers the arrow points to is your droplet's IP address. Please take note of the IP address, as you'll be using it later.

Next, enter the IP address in your browser's address bar (preferably in a different tab), and you'll see a setup page.
On the setup page, you'll see three fields:
- Public Key: By default, this field will contain the SSH key you supplied earlier, so you don't need to do anything. However, if you didn't already upload a key, you can do so here.
- Hostname: If you want to use a domain name, enter it here. Otherwise, enter your Droplet IP address.
- Use virtual host naming for your apps: Only tick this if you're using a domain name since the option isn't available for IP address hostnames.
Click 'Finish Setup' to complete the setup. If successful, it may redirect you to an error page but don't mind it.
Note: You should complete this setup immediately because anybody that visits that IP address before you can insert their pubic key and complete the setup, granting them access to your server as the dokku user.
Once you complete the setup, though, nobody can access the page again.

Prepare for Deployment

The rest of this guide assumes that you're comfortable running commands in the terminal, but here are some things to note if you aren't.

When you see a command with angle brackets like so:

# enter your app directory
cd <your app directory>

Replace the content of the brackets (including the brackets) with the appropriate information. So, in this case, assuming the directory is my-shiny-new-app, the command you type into your terminal window will be:

cd my-shiny-new-app

The line that starts with a # will be omitted because it's a comment. Comments are only there to describe the code or command.

So, with that out of the way, let's proceed.

SSH into your droplet using ssh root@<your droplet IP or domain name> . Replace the <> with your IP like so, ssh root@127.0.0.1
If you get a message in the terminal saying "the authenticity of host <your IP> can't be established," proceed to connect by entering yes.
You should see Warning: Permanently added '<your IP>' (ED25519) to the list of known hosts. and that's fine. If the connection is closed afterwards, rerun the ssh command, and you should now see an output like this:

You'll be deploying a sample Rails app provided by Heroku.
Clone the app on your local machine.

# from the root folder or a folder containing your other repos
git clone git@github.com:heroku/ruby-getting-started.git
# enter into the directory of the sample app
cd ruby-getting-started

In another terminal window, connect to your dokku host (SSH into it like before) and create the app there:

# on your dokku host
dokku apps:create ruby-getting-started

"ruby-getting-started" is the app name I chose because it matches the repo, but you can give it any name you want.

Create The Database Service

This app uses PostgreSQL, so you'll need to install the progress plugin for Dokku:

# on your dokku host
# we're using sudo because the install requires root
sudo dokku plugin:install https://github.com/dokku/dokku-postgres.git

Next, create the database service and link it to your app:

# on your dokku host
dokku postgres:create rails-sample-database

dokku postgres:link rails-sample-database ruby-getting-started

Again, I'm using the name "rails-sample-database," but you can name it something else.
The link method is used like so:

dokku postgres:link <service> <app> [--link-flags]
# service   service to run the command against
# app       app to run the command against

You can learn more about it by running the command below:

dokku postgres:help link

# for a list of all the available commands
dokku postgres

Deploy The App

You first need to add a git remote to your app's repo on your local machine (not on the Dokku host)

# on your local machine
# remote name must be dokku for it to work
git remote add dokku dokku@<our-Dokku-IP>:ruby-getting-started

and push:

git push dokku main:master

That's it! You've successfully deployed your app.

You'll find the URL to your app in the output of the push like so;

=====> Application deployed:
       http://67.207.95.153:20104

This link will only work after manually updating the Droplet firewall to allow your app's port. You'll do so with the command below:

# the port in the URL above is 20104, so insert your app's port
sudo ufw allow <port>/tcp comment 'ruby-getting-started app'

Your app should load up just fine now. Congrats!

If you forget the port for any particular app, you can always check it by running:

# it'll be under 'host port'
dokku proxy:ports <app-name>

Like Heroku, you don't need to configure buildpacks. If you checked the deployment output, you may have noticed that the buildpack identified your application as a Ruby app. This is because the root directory of your app contains both the Gemfile and Gemfile.lock files.

Handling Database Migrations

Instead of remembering to run migrations after every deployment, you can use a Procfile. We didn't create one earlier, and that was fine because Dokku creates a default Procfile for the app if none is found. But we will create one now to add the db:migrate command under the release process type. Here's how:

Enter the root directory of your app in your local machine and create a file named Procfile . Don't add an extension.
Next, paste this into the file:

rake: bundle exec rake  
console: bin/rails console  
web: bin/rails server -p ${PORT:-5000} -e $RAILS_ENV  
release: bin/rails db:migrate

That's it. Now, every time you push to your dokku repo, the release command will run, and the database migration files will run automatically. Click here if you want a general understanding of what a Procfile is.

Some concluding remarks:

Because you only have 1GB of RAM, learn how to create Swap memory using this link. I recommend 4GBs of SWAP. So, change the value of count=1000 to 4000.
Check out the official Dokku docs to learn about all the other things you can do in Dokku.

Note: This article has been updated to make the part about running db migrations into its own section. This change was done to provide a more efficient way of handling the task. I'll continue to make small changes as I learn new stuff.

Thank you for taking the time to read this. If you have any questions or if you found this helpful, please feel free to leave a comment below.