DEV Community: orio

Becoming a Developer in 15 weeks | My Journey Through a Coding Bootcamp and Should You Do It?

orio — Mon, 04 May 2020 20:53:33 +0000

Today marks the first day of the last week of my 15 week Code Bootcamp and it's been quite the experience. Assuming you're reading this article because you have an interest in coding bootcamps, my hope is that this helps provide an inside look of what it's like to attend one.

Before Bootcamp And Why I Decided It Was Right For Me

To be straight first, I'm wasn’t entirely new to web development before starting this course. I have worked on some basic HTML and CSS projects before and I did take a few Udemy courses. My initial idea was to just learn entirely from home. I figured with Udemy courses being only $10-12 on sale and the multitude of online free resources available, I shouldn't have any issues learning everything online. However, I found out that it wasn't the best option for me.

While it is entirely possible to learn everything from home and probably for free. I didn't think it was right for me. A here are a few of my reasons:

Time: I already really enjoyed programming and I knew it was right for me. But, while looking into it, learning from home without much of a structured environment or curriculum pointing me in the right direction, wouldn’t be as painless as I thought it would be. Reading a lot of other blogs and came to realize it might take quite a bit longer than I anticipated. Plus I wasn't sure at what point I'd be ready to work.
Environment: One smaller thing bootcamps provided was the environment. Being able to socialize with people in the same position with similar mindsets and having instructors and coaches on standby appealed to me.
Career Services: Most bootcamps offer some sort of career services like helping you build a great resumé and online presence, mock interviews, and other such support while job searching.
Soft Skills: One major thing companies look for today is soft skills. Having always taught myself and being more of a shut in. I didn't want to be lacking any social skills or be in the position of my being able to explain my code or thought process to my coworkers.

After My Decision/Deciding Where I Should Go

After I figured out I wanted to attend a bootcamp. I spent a lot of time figuring out which bootcamp I wanted to go to. Even though it was a bit of a commute. I decided I should probably look for schools in San Francisco. I spent hours reading student reviews and blogs. Reading into each camps website carefully until it came down to two options. I went through the prep work of both camps, went through a personality and technical interview with both and was accepted by both schools. Ultimately I decided to go with Flatiron as more of a gut choice since both schools on paper seemed almost identical. However, my choice was mainly persuaded by the vibe I was given. Plus I was also able to check out the Flatiron campus before hand, while my other option I didn't really have that ability until after I wanted to make my decision.

During Bootcamp

Unfortunately towards the middle-to-end point of my program the Covid-19 pandemic stuck forcing us to work from home. But, during my time on campus, the only complaint I had was the commute. Traveling from the Central Valley to San Francisco took about 4 hours each day, 5 days/week. Other than that, I love every second of it. Of course at times I struggled and I tend to be the type who just likes to figured things on my own. But one thing I realized is asking for help is often the best thing to do if you start getting too stuck. Because often what might be challenging for you, someone might have a little more experience in it to help you where you might get confused. Or you just misspelled a variable and you just need a set of fresh eyes.

After Bootcamp?

Well I'm not quite sure yet, like most, my program offers career coaching and I'm just getting started on that. From just the one meeting I've had with my coach, I felt pretty confident that with their help, I'll be able to land a job within 6 months. But, my plan is to update this part when and if that time comes.

Should You Go To A Coding Bootcamp?

I would say it depends. Before asking that question, I feel you should first ask yourself if you really want to become a developer. Seek out real experiences from actual developers and find out what their daily life is like. While not trying to discredit "Day in the Life" videos, they often don't paint an accurate picture of an actual daily life. At least, that's what I've understood from the majority of developers who say otherwise. Also try practicing a bit at home first. Take a few Udemy courses (courses by Colt Steele are great) or theres also plenty of free options available.

But my answer is, if you answer to that question is "Yes", and you want an accelerated learning experience, have the savings or someone who can support you, and can afford it. I'd say a bootcamp for me was one of the greatest experiences of my life and it's a bit of a bitter sweet ending. While I'm a bit sad this is all over. I'm excited for the future I've been prepared for.

Discord.js | Creating a bot for Discord 🤖

orio — Thu, 09 Apr 2020 23:42:04 +0000

0.0 Introduction

Welcome to my short tutorial on creating a bot for Discord. Just as a note, this tutorial won't be going too in depth on every single bit of code being written, it's meant to serve as a quick guide to getting starting creating your own Discord bots. Think of this as a template.

Creating the Bot in Discord
Setting Up Our Environment
Writing the Bot
Running the Bot
Adding the Bot to a server

1.Creating the Bot in Discord

Let's get started by creating a Discord Application

1.1 Visit the Discord Developer Portal and click "New Application"

1.2 Go to "Bot", the click "Add Bot"

After creating the bot, we're met with a screen that gives as access to some of the bots settings. We don't need to worry too much about anything here besides our "TOKEN". We'll need this so our bot will be able to connect to the Discord API. Click "copy" paste this somewhere safe for a moment.

2. Setting Up Our Environment

Now we've creating essentially the Discord account our bot will run on. We now need to start writing some code to give some life to our bot. However before we do, we need to setup our environment.

In your terminal, run the follow commands

mkdir my-app
cd my-app

yarn init
// or npm init

touch index.js config.json && mkdir client commands
touch client/Client.js commands/help.js

Nice! Now we have almost all the files we need. Now we need to install the Discord.js module.

yarn add discord.js

And there we go. We've got our environment setup. Now time to add some code...

3. Writing the Bot

3.1 The config.json File

In ./config we need to add a few lines that configure our app.

{
  "prefix": "#", //set to what you want your command prefix to be
  "token": "YOUR-TOKEN"
}

The "prefix" is the character(s) you want your bots to listen for and "token" is the token you copied from the Discord Bot

3.2 The index.js File

const fs = require('fs');
const Discord = require('discord.js');
const Client = require('./client/Client');
const { prefix, token } = require('./config.json');

const client = new Client();
client.commands = new Discord.Collection();

The first few lines will just we requiring a few files. Don't worry too much about these lines, except take a look at the line const { prefix, token } = require('./config.json'). This is destructuring our config.json file and setting it to const variables we can use later.

const commandFiles = fs
    .readdirSync('./commands')
    .filter((file) => file.endsWith('.js'));

for (const file of commandFiles) {
    const command = require(`./commands/${file}`);
    client.commands.set(command.name, command);
}

Again some lines that just paired with a quick explanation. Here we are setting commands that are available to our client.

console.log(client.commands);

client.once('ready', () => {
    console.log('Ready!');
});

client.once('reconnecting', () => {
    console.log('Reconnecting!');
});

client.once('disconnect', () => {
    console.log('Disconnect!');
});

Here we're logging to our console our client commands and the status of our bot.

client.on('message', async (message) => {
    const args = message.content.slice(prefix.length).split(/ +/);
    const commandName = args.shift().toLowerCase();
    const command = client.commands.get(commandName);

    if (message.author.bot) return;
    if (!message.content.startsWith(prefix)) return;

    try {
        if (commandName == 'ban' || commandName == 'userinfo') {
            command.execute(message, client);
        } else {
            command.execute(message);
        }
    } catch (error) {
        console.error(error);
        message.reply('There was an error trying to execute that command!');
    }
});

Finally, on to an interesting part. Here the bot is listening for a 'message' event and running some code based on that message.

const args = message.content.slice(prefix.length).split(/ +/);
const commandName = args.shift().toLowerCase();
const command = client.commands.get(commandName);

Here we're parsing out our command.

if (message.author.bot) return;
if (!message.content.startsWith(prefix)) return;

These lines are just checking if the message is first, send by out bot, and if the message starts with our set prefix, prefix coming from our ./config.json. If the conditions for the statement are true. Then we return.

try {
    command.execute(message);
} catch (error) {
    console.error(error);
    message.reply('There was an error trying to execute that command!');
}

Now finally, finally, the part that actually runs the command. First we try to run the command with command.execute(message), if that didn't work, our catch() will tell our user something went wrong.

3.3 The Client.js file

const { Client, Collection } = require('discord.js');

module.exports = class extends Client {
    constructor(config) {
        super({
            disabledEvents: ['TYPING_START'],
        });

        this.commands = new Collection();

        this.queue = new Map();

        this.config = config;
    }
};

Here's a short and sweet file. All we are doing here is exporting our Client class that basically holds on to our commands and other info. If you check back at line 3 on index.js, you'll see we're requiring this file const Client = require('./client/Client');

3.4 The Commands

const fs = require('fs');

module.exports = {
    name: 'help',
    description: 'List all available commands.',
    execute(message) {
        let str = '';
        const commandFiles = fs
            .readdirSync('./commands')
            .filter((file) => file.endsWith('.js'));

        for (const file of commandFiles) {
            const command = require(`./${file}`);
            str += `Name: ${command.name}, Description: ${command.description} \n`;
        }

        message.channel.send(str);
    },
};

This is a simple 'help' command, feel free to copy and paste this for your own bot. But let's go over something a little simpler.

module.exports = {
    name: 'command-name',
    description: 'a bit about the command',
    execute(message) {
        let str = 'hello world';
        message.channel.send(str);
    },
};

Here's a command template you can use for your own bot. Since you'll be spending most your time in this type of file. I'll go a little more in-depth.

Let's start with name: here's were you want to set what you want to command to run by.
description: It's a bit optional, but helpful for when your users use the 'help' command. Just set this to a string that describes the command.
execute(message){//your code} now for the meat of our command. Between those curly braces, you'll want to add the code that'll be executed once the command is called.

All of this gets wrapped in a JavaScript object that then get's exported with module.exports = {//object you created}

Now all you have to do when creating a new command is follow this template and write the code you'd want to execute within that execute() function.

4. Running the Bot

Finally, to run our bot, we'll want to open our package.json file and include a scripts object.

Something like this

    "scripts": {
        "start": "node index.js"
    }

We'll want to add so our entire file looks something like

{
    "name": "my-bot",
    "version": "1.0.0",
    "main": "index.js",
    "author": "your-name",
    "license": "MIT",
    "dependencies": {
        "discord.js": "^12.1.1"
    },
    "scripts": {
        "start": "node index.js"
    }
}

Then in our command line, just run

yarn start
//or npm start

You now have a fully functioning Discord Bot.

5. Adding the Bot to a server

Adding the bot to a server is very easy

Make sure your an admin/owner of the server you're trying to add the bot to.
Visit your bot's application again
Go to the "OAuth2" tab
In the "OAuth2 Generator" check "bot" and copy the link
Finally, visit the link and add the bot to your sever.

6. Conclusion

Thanks for reading. This was an extreme overview of creating a Discord Bot. I'll link more examples and below and some documentation.

Discord.js
Bot I learned from
JavaScript MDN

The differences between forms in Rails

orio — Thu, 05 Mar 2020 21:08:11 +0000

Note: This blog is more intended to show the differences between the different form helpers in Rails and not so much to explain how they work and how to use them

You might be new to Rails hearing about form_for, form_with, for_tags, and fields_for for the first time thinking, "What's with all these forms and fields?" and "When should I use a specific one?" All of these are form helper methods. We can take advantage of these in Rails with Embedded RuBy (erb) to create forms that render HTML. You might say? "Why not just build out a form in HTML? Using erb seems a lot more complicated." Well, to put in plain and simple. It just makes it easier, at least once you get the hang of it.

Form Helpers vs HTML

Using form_for

<%= form_for(@cat) do |f| %>
  <%= f.label :name %>
  <%= f.text_field :name %>
  <%= f.label :color %>
  <%= f.text_field :color %>
  <%= f.submit %>
<% end %>

vs HTML

<form accept-charset="UTF-8" action="/cats" method="post">
  <label for="cat_name">Name</label>
  <input id="cat_name" name="cat[name]" type="text" />
  <label for="cat_color">Color</label>
  <input id="cat_color" name="cat[color]" type="text" />
  <input name="commit" type="submit" value="Create" />
</form>

Let's compare the two forms. On the top we're creating a form using form_for in erb. Below we have what that bit of code creates in HTML/what we would have had to write in HTML. Except that in the form helper version, we didn't have to set our action path nor what method we wanted to use. Rails did that for us.

So what exactly is going on? form_for is taking in an instance of @cat and working with a FormBuilder |f| to create fields for that model. Assuming we had a create method in our CatsController, clicking submit in our above example would POST a @cat to the "/cats" route adding a new row to our database with the user set attributes.

What's the difference between all the Form Helpers?

Ok, I'm hoping by this point I've convinced you to start using form helpers instead of writing out your forms in HTML. But now I hear you asking, "What's the difference between form_for and form_with?" or "What even is fields_for?" All will be explained going forward.

Note: form_tag and form_for are being depreciated in replace of form_with. However, at the time of writing this, both for_tags and form_for still work so I will be including them.

form_tags

<%= form_tag("/cats") do %>
  <%= label_tag('cat[name]', "Name") %>
  <%= text_field_tag('cat[name]') %>

  <%= label_tag('cat[color]', "Color") %>
  <%= text_field_tag('cat[color]') %>

  <%= submit_tag "Create Cat" %>
<% end %>

form_tag is probably one of the more simpler and versatile form helpers. It builds us a simple form in HTML using the path we pass it. In this example, our action is the cats_path and it's setting our method to POST for us. Submitting this form (assuming we had a cats#create route and controller) would POST a new cat to our database.

form_for

<%= form_for(@cat) do |f| %>
  <%= f.label :name %>
  <%= f.text_field :name %>
  <%= f.label :color %>
  <%= f.text_field :color %>
  <%= f.submit %>
<% end %>

Now this is where that Rails magic starts. form_for works with an
instance of a class and you'll be able to create and update it's attributes. Plus if the instance you are referring to in the form already has set data. That data will populate your form, and Rails is smart enough to know it's an existing entry in the database and submit this form as an update.

When should you use `form_for` over `form_tag` and vice versa?

form_tag just creates a form in HTML. form_for on the other hand is great for working with data that connects with a model. A good example of when to use form_for is when we were working with out @cats model. We could easily call a specific cat.

form_with

<%= form_with url: cats_path do |f| %>
<%# You could also pass an instance such as @cat %>
  <%= f.label :name %>
  <%= f.text_field :name %>
  <%= f.label :color %>
  <%= f.text_field :color %>
  <%= f.submit %>
<% end %>

form_with is, at least the way I see it. The bridge between form_for and form_tags. It's meant to unify the two and replace them.

fields_for

<%= form_for @recipe do |f| %>
    <div>
        <%= f.label :title %>
        <%= f.text_field :title %>
    </div>

    <%= f.fields_for :ingredients do |ing| %>
        <p>Add Ingredient</p>
        <div>
            <%= ing.label :name %>
            <%= ing.text_field :name %>
        </div>
        <div>
            <%= ing.label :quantity %>
            <%= ing.text_field :quantity %>
        </div>
    <% end %>

    <%= f.submit %>

<% end %>

In this example, let's say a we have Recipe and Ingredient class. A Recipe has many Ingredients and a Ingredient belongs so a Recipe. When we create a recipe, wouldn't it make more sense to add ingredients in the same form we're creating the recipe itself? That's were nested forms comes in. Since this isn't entirely meant to be a how-to blog and more so to point you in the right direction. I won't be going too deep into how to create a nested form.

What fields_for is allowing us to do is create a nested form that would then send the :ingredients nested in our params like params[:recipe][:ingredients_attributes]

Hopefully after reading this you might be able to understand when to use the different form helpers in Rails. Again this post wasn't really meant to include how to use create forms.

References and further reading

How to generate random cities in Ruby

orio — Wed, 12 Feb 2020 20:59:03 +0000

In true blog fashion, I'm going to give you my life story before getting into the true meaning of this blog. My name's Austin and I'm currently attending the Flatiron bootcamp in San Fransisco. To finish off the 3rd week, we were assigned a project. We were tasked with creating a Command Line CRUD app that used a database to persist information. My partner and I decided build an app that would generate a random city and allow users to store a list of cities (travel destinations) and provide some data based around that location (eg: weather and events). Basically, an app for the wanderlust user looking for ideas for a spontaneous vacation. Similar to throwing a dart on a map. One of my jobs was to build the part of the app was would generate the random travel destination.

I figured, it would be easy. I should be able to find some blog article or Stack Overflow post on someone trying to do something similar with a solution provided. 3hrs later... I was still looking. I found some solutions that kind of worked. One example was using a series rand()s to generate random latitude and longitude coordinates then using the Google Maps API to find out where that location was. However, annoyingly, the Earth is over 70% water. Meaning 70% of the time, it would tell our users to go to a random location in the ocean.

I knew that wasn't going to work. At first, I figured, I could try to check against the API data if the coordinates was an actual location. Then just keep generating new coordinates until actual place a user could visit was found. But I figured, that probably wasn't the most efficient solution. Not only would it make the app unbearably slow (theoretically, it could never actually find a location not in the ocean), but it would also call the API each time we generated a new location. While Google's $200 in free credits it more than enough for this project. Calling an API numerous times, each time the user searched for a new travel destination, can become extremely costly if we had a user base with hundreds of thousands of users. So I knew I had to find a better way.

After giving another round of Googling a go. I found something that worked well for me, and I want to share my solution.

1.Prerequisites

a. Unless you have and know how to use Wget. I suggest following this guide on how to setup and use it. Setting up and using Wget

b. Here's a quick list of gems we'll be using. (This guide assumes you have all the gems installed and required)

gem 'countries'
gem 'cities'

2. Getting our data

To get all of our data, I used a the cities gem. The cities gem was built as an extension of the counties gem using the MaxMind database. You'll need to install and require both gems. Now about that database.

To download our data, we're going to run in our terminal...
$ wget https://s3-us-west-2.amazonaws.com/cities-gem/cities.tar.gz
Then run.. $ tar -xzf cities.tar.gz to exact the data we just downloaded.

3. Building the method

#requires

Cities.data_path = 'path/to/cities'

def generate_city
    country = ISO3166::Country.all.sample
    city = country.cities[country.cities.keys.sample]
end

=> #<Cities::City:0x00007fac7a559938
 @data=
  {"city"=>"tsekelewu",
   "accentcity"=>"Tsekelewu",
   "region"=>"17",
   "population"=>nil,
   "latitude"=>"5.9833333",
   "longitude"=>"4.9833333"}>

So what's going here? Lets go over each line...

Cities.data_path = 'path/to/cities'

All we are doing here is setting the relative path to where our folder of cities we downloaded is located on our system.

country = ISO3166::Country.all.sample

Here we're setting the country variable to a random country from the country gem.

city = country.cities[country.cities.keys.sample]

Since country.cities returns a hash of city objects...

country.cities

 => {"canque"=>#<Cities::City:0x00007fdf17082250 @data={"city"=>"canque", "accentcity"=>"Canque", "region"=>"04", "population"=>nil, "latitude"=>"-44.5333333", "longitude"=>"-68.3666667"}>,
 "canquel"=>#<Cities::City:0x00007fdf17082200 @data={"city"=>"canquel", "accentcity"=>"Canquel", "region"=>"04", "population"=>nil, "latitude"=>"-44.5333333", "longitude"=>"-68.3666667"}>,
 "cantadero"=>#<Cities::City:0x00007fdf170821b0 @data={"city"=>"cantadero", "accentcity"=>"Cantadero", "region"=>"12", "population"=>nil, "latitude"=>"-29.2166667", "longitude"=>"-66.8666667"}>,
 "cantera aguirre"=>#<Cities::City:0x00007fdf17082160 @data={"city"=>"cantera aguirre", "accentcity"=>"Cantera Aguirre", "region"=>"01", "population"=>nil, "latitude"=>"-37.35", "longitude"=>"-59.0"}
}
# this is just a small segment

we can't just chain method .sample on. We'll have to use the .keys method to return an array of keys, then .sample to return a random key from that array.

Just search for the that random key in the country.cities[key we just sampled] hash and we get returned a random city from that country.

city = country.cities[country.cities.keys.sample]

=> #<Cities::City:0x00007fac7ad72188
 @data=
  {"city"=>"fatiau",
   "accentcity"=>"Fatiau",
   "region"=>"00",
   "population"=>nil,
   "latitude"=>"-19.1166667",
   "longitude"=>"-169.9"}>

And finally, we are able to generate a random city for our users to travel to. This was a fairly basic run down on how I figured out how I can generate random cities for our project. If you're interested, be sure to check out the references I left below for the documentation on all the gems. Also, if you'd like to see a working example, I've included the link to the projects GitHub repository in the References section below.

Some issues I ran into

Returning the city name I had 1 small issue when trying to return the city's name. At first I tried using city.city, since that's what the hash was returning. I figured out after using .methods I was able to use .name to return the city name.