DEV Community: agandaur-ii

JavaScript Cheatsheet

agandaur-ii — Mon, 17 Aug 2020 06:26:47 +0000

If you're like me and find yourself trying to gain a better understanding of algorithms, you've come to the right place. Why do I need to know them, you ask? That is outside the scope of this post, but there are lots of articles out there on the subject. At the end of the day: you just need to know them.

So as I go on my pilgrimage of algorithm enlightenment, I have found myself frequently going back to certain things and needing to look them up online. Often, these things will be basic parts of the language, but under the pressure of finding a solution to an algorithm, I find my mind going blank. To overcome that, I've come up with a list functions and a quick description of what it does to help jog my memory. Here it is for you too in case you need that lightbulb to go off.

I will note that these are meant to be quick notes, not a full summary of what the function can do. Always read the documentation to fully understand what you are using!

array.pop() => removes the last element of an array

array.shift() => removes the first element of an array

array.push() => adds element(s) to the end of an array

array.unshift() => adds element(s) to the beginning of an array

array.slice() => cut at a starting index, and optionally an end index. Original array not modified

array.splice() => changes contents of array in place

const a = "index to start at"
const b = "number of elements to be removed"
const c = "element(s) to be placed"
=> to insert: .splice(a, b, c)
=> to delete: .splice(a, b)
=> to replace: .splice(a, 1, c)

string.split('') => string to array of string elements

array.join('') => array to string of array elements

parseInt(stringThatRepresentsNumber) => string to number

Math.max(num1, num2, ...) => find largest number
Math.min(num1, num2, ...) => find smallest number
Math.sqrt(num) => square root of num
Math.pow(num, power) => num to power x
Math.ceil(num) => rounds up
Math.floor(num) => rounds down

[...new Set(array)] => creates an array with unique elements

array.sort((a,b)=> a-b) => appropriately sorts an array of numbers

Need to get each individual digit of an array?

     while(num > 0) {
          last_digit = num % 10
          console.log(last_digit)
          num = Math.floor(num / 10)
     }

I am sure there are plenty more helpful bits out there, but these are the ones I run into most frequently. Have any other "go-tos" that I didn't list here? Add a comment with them and we can keep this list growing!

Should I go to a Bootcamp?

agandaur-ii — Fri, 07 Aug 2020 18:17:34 +0000

If you are reading this post, you are more than likely contemplating the question above. Perhaps you have been wrestling with this question for a few days or a few weeks - I know I did when I was in your shoes. For me, it was helpful to read about the experience of others before making my decision, so read on to hear my thoughts on the matter. I hope reading about my experiences will help you too.

The first thing to consider is your current proficiency with coding skills. Have you never touched the stuff? Just done it for fun? Taught yourself the basics? I had very little exposure to coding before starting my bootcamp, so jumping into anything online was intimidating. I would definitely recommend giving the 'Teach Yourself' route a go first. See how fast you pick things up and how you do with solving problems on your own or with the help from folks online. There have been many success stories for self-starters, and if you have the grit and proficiency for it, there is the potential to do it all for free.

I tried my hand at teaching myself, and I felt like I needed a bit more support, as I tend to thrive when part of a community. It's absolutely possible to create your own coding network online through Discord DMs, Stack Overflow questions, etc. If you want more face-to-face interactions and individualized support like I did (even if that is through Zoom calls, like everything else is nowadays), then start looking at what bootcamps can offer you. There are many different options out there, so do your research to find which program is best for your financial needs, work style, and schedule. I choose to do the in-person course through Flatiron School, so I will talk about the experience I had there. Mileage may vary depending on the bootcamp you attend.

In comparison to teaching myself, having scheduled course instruction with a dedicated instructor was quite refreshing. The ability to talk to someone face-to-face about issues or bugs is invaluable, especially when you know your instructors and those around you have gone through the same experience. Sometimes you'll get lucky online doing this, where the exact bug you are fighting has already been solved, but being in a bootcamp made it felt like this was the norm rather than the exception. Being surrounded by other students learning the same material and working through the same projects helped with my motivation, especially when finding myself inevitably stuck. Being able to talk to and rely on other bootcamp members helped me get through some rough patches where I may have given up if I was still just teaching myself.

Now for the money. At the end of the day, no matter what bootcamp you are looking at, you will need to put down a large sum of money. If you don't have that kind of money on hand, look carefully into your option on how to borrow. If the school if offering something like financial aid or an income share agreement, make sure you read the fine details so you know exactly what you are getting into. For example, Flatiron offers a money-back guarantee if you don't get a job within 6 months of graduating. There is a lot of money on the line here for them (they are a business, after all), so they have some serious stipulations on how that guarantee works. However, they also have a lot of dedicated support systems designed to help you start your career in the field. Make sure you identify and understand those fine details before you sign your name anywhere.

Now of course, having just dropped a lot of cash or taken out a considerable loan, you find yourself stuck worrying "Well, now I will be out of a job for awhile..."

At Flatiron, the course lasted 15 weeks. I saw some other bootcamps were anywhere from 12 - 17 weeks, so look around to see what works with your schedule. However many weeks it is, it will be short. You will gain the skills that you need to graduate and then you will be straight into the job hunt. One of my major considerations when looking at bootcamps was how long the course was. I got stuck into thinking that once the program was over, I would have a job shortly afterwards. Don't get stuck in this mindset--it's likely that employment post-bootcamp will take some time. This is not to say that you can't get a job the week after you graduate, but I would not make your financial and scheduling plans banking on this specific outcome. My suggestion is to plan for your unemployment to be much longer than the duration of your studies.

So then that begs the question, should I look at a school that has a longer duration? I believe there are some potential benefits to a longer program. One of the challenges of completing a shorter bootcamp is that you come out with only a few month's experience. That's it. You also don't have an official degree, you don't have four years of experience. There are plenty of bootcamp grads that have landed awesome jobs, though, so don't think of the bootcamp route as narrowing your future job options. However, you will need to be prepared to apply to positions that ask for more experience than you have. This is pretty common for any industry, but I advise you to go into the job hunt knowing that there aren't many job postings specifically asking for bootcamp grads (if there are, I have not found them yet). Some companies will offer positions designed for recent graduates, but those listings are also pulling from college attendees or recent graduates with degrees in computer science. You can still get these kinds of jobs, just know who and what you're up against.

If you have the time and financial resources to complete a longer bootcamp through a college or university, I would definitely consider it. You'll come out with more experience under your belt and potentially have a degree as well. Are these things to just pad your resume? Perhaps. Regardless, take the time to look into all of your options to see what is going to give you the best chance for success.

Another thing to keep in mind is that you will not have learned everything by the time you graduate. Will you learn a lot? Absolutely. You will be impressed with the amount of knowledge you gain through the course of your bootcamp, but once you're out in the world you will quickly feel small. And that's okay. You just started out and there will always be new things to learn, especially in the software world where things are updated and created so rapidly. The important thing to remember here is that you will be teaching yourself how to learn throughout the bootcamp. This skill is one you will need to continue fostering and one that will be incredibly valuable to any company that you end up at. There's always something new to absorb, even something that your senior software engineer friend doesn't know about yet. Learn the old stuff (as long as it still applies, of course), definitely learn the new stuff, but whatever you do, just keep learning.

A word of warning: it is called a bootcamp for a reason. This is by no means a walk in the park. If you don't do well under pressure or with high amounts of stress, I would strongly consider looking into a longer course option. Even though the advertisements say that you'll only be at school for a set number of hours per day, you will need to work evenings, early mornings, and weekends to keep all of the new material from escaping your brain. It's hard work. You will be stressed. You will want to quit multiple times throughout the course. But you can do it. Just know that it will not be easy.

Having a community of bootcamp peers was a huge boon for my success, so lean into those new relationships because you are all going to need each other. Perhaps this is not a benefit you were necessarily looking for, but it is in these types of high-stress scenarios where you make friends. Usually very good friends. You spend 15 weeks with these new people, all going through the same rigorous process, all working together to solve problems and gain new skills. This sort of camaraderie is what brings people together. If you are new to a city like I was, coming out with new friends in the field was a great cherry-on-top to my experience.

Hopefully all of that helps answer some of your questions. Maybe even the big one of whether or not you'll go to a bootcamp. If there is anything I missed or something you still have questions about, let me know in the comments and I'll get back to you as best I can. Good luck with your decision!

Quick Tips

agandaur-ii — Fri, 31 Jul 2020 00:44:29 +0000

As I am sure many of you can relate, teaching yourself to code is hard. Even with going to a bootcamp, it's just a start. The farther away I get from my graduation date the clearer it becomes that I still have so much to learn.

Thankfully, I have some developer friends in the industry that have been giving me some tips and tricks to help me hone my new skills. But for anyone out there that may not have that luxury, here are a few things I have picked up from them along the way.

1. Always save

This seems almost ridiculous to mention, but it has caused me countless headaches. Why is this page not behaving the way I am expecting it to? I followed the tutorial exactly... What could I have possibly done wrong?? It just wasn't saved.

2. Make sure new changes are pushed/deployed

In a similar vein to the first point, your code may be working locally just fine, but if those new last minute changes weren't deployed, your app is going to look the same as it did yesterday.

3. Don't add things to the end of your host link

Speaking of deploying, make sure your host link doesn't have any hanging /'s or additional text. This cost me a number of hours of scouring the internet only to discover that a single "/" was the source of all my problems. If you are using an api controller structure (like api/v1) make sure you leave that off of your host link as well.

4. Find where your methods are coming from

Have you ever misplaced one of your methods in your rails app? Look no further than this:

MyClass.method(:method_i_am_confused_about).source_location

It'll point you right down to the line number where that sucker is located.

5. Did I add this method?

Can't remember if this method is one that you added or one that came out of the box? Give this a try:

MyClass.new.method - Object.new.method

6. Stop using git commit -m "My commit message"

Your git commits should be telling a story of how you write your code. It should be like writing a short, professional email to your future self and/or the team you are working with that describes exactly what you did. Check out this article to level up your git commits.

7. Fix mistakes in your git commits

It's a story now, and a professional one at that. But we are all human; we make mistakes. Lean on git commit --amend for when that happens.

8. Check out git rebase

Following along with the story, merging can make things murky. Check out the documentation for git rebase to find out when it is best to merge or best to rebase.

Rails & React: Passing an Image Between Them

agandaur-ii — Fri, 24 Jul 2020 05:26:24 +0000

So you have an app. What would make the app better? I know, let's have the user be able to upload an image to her account! Every app out there does this, so it must be easy, right?

These were my thoughts for my application I was building. To be clear, at least for me, it was not easy. But hopefully, with a little help from this post and other helpful angels that helped me get to this point(more on this below), you too can upload an image to your application. I will note that this was just the solution that I was able to use for my specific application, where your application may benefit more from a different approach. But if you are using a React frontend and a Rails backend, read on for at least one of many solutions you can use!

Let's start by diving into the frontend. First we need to get the picture into our application, which I did by using a form. How do you allow an image to be uploaded via our form? After looking around for a bit, I settled on using the ImageUploader package (documentation here) but there are many other options to choose from if the layout of ImageUploader isn't what you are looking for. Once ImageUploader was installed and imported into the file my form is on, all I had to add to the form was the following:

  <Form.Group >
  <ImageUploader
    withIcon={true}
    buttonText='Choose images'
    onChange={event => this.onDrop(event)}
    imgExtension={['.jpg', '.png', '.jpeg', '.gif']}
  />
  </Form.Group>

Seen on the page, the form will look like this:

A few things to notice. Form.Group comes from react-bootstrap. If you are not using react-bootstrap, it's easy to add in the same chunk of code as a new element in your form in whatever way you decide to divide up your form options. ImageUploader comes with its own icon to display. If you don't like the icon it provides, you can turn withIcon to false. The buttonText can be changed to display whatever text you wish and you can also change the imgExtension array to limit image formats you may not wish to accept.

Finally, there is a mandatory onChange that ImageUploader will need, in this case an onDrop. The corresponding function will look like this:

    onDrop = picture => {
        this.setState({ image: picture[0] })
    }

I am using state to store the form properties, which setState works great for. I am only allowing the user to upload one image at a time, so simply calling picture[0] was sufficient for my needs. There are ways to upload multiple images, but I will not be delving into that in this post.

Now that we have the image in state, let's send that to our backend. Almost halfway there already!

I used a dedicated api file to store all of my api calls to my Rails application, but however you make your calls, you will need to implement something called FormData in order to correctly send the image data from your React app to your api. What is FormData, you ask? I would ask good ol' Google to make sure you fully understand what it does, but for the purposes of this post I will just state that we will need to use it.

An important thing to note about FormData in a fetch request is that it does not need "Content-Type" or Accept headers. In fact, if you include them in part of your headers, the FormData (and therefore the image) we are trying to send will not work as intended. If you're like me and used a headers helper method in your api file, like this:

const headers = () => {
    return {
        "Content-Type":"application/json",
        Accept: "application/json",
        Authorization: token()
    }
}

be sure to manually input your headers into the fetch request that will be sending FormData. In my case, it looked like this, as I still needed the Authorization to be send over:

const createBoard = (boardObject) => {
  let nestedObject = {'board': boardObject}
  let formData = objectToFormData(nestedObject)

  return fetch(`${API_ROOT}/boards/`, {
    method: "POST",
    headers: {Authorization: token()},
    body: formData
  }).then(res => res.json());
}

Creating a specifically formatted FormData can be a little tricky, so I employed the help of object-to-formdata(documentation here). Once you import object-to-formdata into your file, simply pass your desired object into an objectToFormData function and, wa-la!, you have FormData that can easily be send to your api.

Instead of reinventing the wheel, for the bulk of the Rails work, I will pass you into the very capable hands of this post that helped me out of my own dark times of uploading images. A big thank you to the author. Check it out from part 2 onward and give him a like and a follow. He makes great stuff. Before you go, I have a neat trick to show you once you are done reading his article. If you get to the custom serializer and think, "Is there another way to do that?", head on back here for my final say.

Yay! Now you have a ActiveRecord up and running and a new Cloudinary account. You'll recall that in your model that receives an image, you put this bit of code:

  def get_image_url    
    url_for(self.image)  
  end

If you want an easy way to grab that info in your serializer, throw this into the serializer that will be sending the image back to your React app:

  link :custom_url do |object|
    "#{object.get_image_url}"
  end

You'll now have a new element in your JSON object that gives you your link!

Hopefully now all of your image uploading dreams have come true. Have any suggestions on further optimization? Do you have a better way of doing this all together? I would love to hear them! You can help me continue to learn along with anyone else who drops by in the future.

Thanks for the read and happy hacking!

Looking Forward

agandaur-ii — Thu, 09 Apr 2020 22:04:56 +0000

With just about four and a half weeks left in my coding bootcamp, it feels like I will be done by tomorrow. For so long it seemed like time was standing still while I was cramming my brain with all this new information. Now it seems that I am hurtling toward the unknown with no way to slow down. I can see the light at the end of the tunnel now, but that light is fairly uncertain, as it's under quarantined too.

So with unspeakable haziness ahead of me, I wanted to take a look at the industry I'm going into and see some of the positive things it has done or is trying to do. Especially in times like these, being able to make a difference in the world is as imperative as ever, and thinking positively can't hurt anything, right?

First, it's crazy to me that computers used to look like this:

and this:

and now this:

That last one is a quantum computer. Read more about it here: https://www.princeton.edu/news/2020/01/21/quantum-computing-opening-new-realms-possibilities. It's quite fascinating!

But for all of these computers, and for those that created them, what are they trying to do? Most of them start at just trying to solve a simple problem. One was to help count all of the results of a census, another was to decrypt secret messages in WW2, while others focus on running just one algorithm. As it masters that task, it then moves on to the next, and then the next, etc. etc. until we arrive where we are now, where the computer I am typing on can do even more things than I can currently comprehend. But it all comes back to problem solving. What is something in the world I can solve, whether big or small, with a computer? A whole world of possibilities.

And like the earliest of computers, I don't need to focus on solving the biggest problems. One small problem I solve this week could potentially be built off of in the future, which then gets built off of, until eventually it becomes something I could never have achieved on my own. The same logic goes for working on a project for a company; it could eventually become something revolutionary or groundbreaking. Although in these cases you may not necessarily know what your small contribution eventually becomes, it goes to show that I don't have to work for NASA or the CDC to make an impact on the world.

Having an impact on the world can mean vastly different things depending on who you talk to. So this list may not be agreeable to everyone, but below are some interesting things, to me, that I think have made an impact. And, of course, the all star to all of this is the computer itself that made way for, or greatly enhanced, all of these possibilities.

Exploration

Finding new planets, distant stars, or black holes; it all starts on someone's computer! Even exploring our own planet is now deeply tied to advanced computer behavior and analytics.
A.I/Machine Learning

Of course this eventually leads to robots taking over the planet, but it'll be very beneficial up until that point!
Video Games

Even if you don't enjoy video games, the advancements in entertainment from this industry are astounding. There are games that pass the time, games that are competitive, some educational, and some even therapeutic.
Time Management

OKAY, this one may be a little out there, but think about it--how dependent are we as a society on time? From when we get to go home for the day, to when we catch a flight, to when we wake up in the morning (and so many more things!) all depend on time. It makes it easy to discount software in these fields as "that's just how it is", but imagine where we would be without it!
Social Networks

Another one that may raise some eyebrows, but with the ever expanding human population, keeping in contact with loved ones and friends has never been easier. Especially now with everyone being stuck indoors, it's helping to redefine what a community can be.

So if I end up doing something similar to the above, I'll be happy. Even if not, something I do may end up contributing to those fields someday and that would be just as well. So for anyone else who feels unsure or uneasy, you'll do great things in your future too. Don't be afraid to start small. And I'm saying this just as loudly to myself, but just get out there and start doing something--anything--as you never know what it might turn into.

rails g shortcuts

agandaur-ii — Tue, 24 Mar 2020 21:35:21 +0000

Been living in the rails world for awhile now and I am learning to appreciate all of the short cuts it provides you. Since I have been creating a lot of new apps from scratch to practice, I am especially appreciating the generate shortcuts that you can perform when setting everything up. So I wanted to create a short list of the generator shortcuts that I find to be most beneficial for me, and hopefully for you too!

The best part is that for any generation instead of writing:

  rails generate [thing to generate]

You can just write:

  rails g [thing to generate]

Neat!

The next part of building your app is, most likely, setting up database. Once you go through all of the steps of figuring out what you want on all those tables, you can get started on creating those files. Without the generator, you would go into your db/migrate folder, create a file for your table, set up the class (making sure it inherits from ActiveRecord), write the change method including create_table and all the following column names, etc., etc...

That was a lot just to write, let alone code! Thankfully, rails g migration will take care of all of that for us. Let's say we are creating a flight app of some kind. We'll need planes for that, so if we wanted to create a table for our planes all we would need would be something like the following:

  rails g migration CreatePlane model:string callsign:string

which will produce:

 class CreatePlane < ActiveRecord::Migration[6.0]
    def change
      create_table :planes do |t|
        t.string :model
        t.string :callsign
      end
    end
 end

We can simplify even more but writing:

  rails g migration CreatePlane model callsign

as rails will automatically assumes that the column type will be a string if we do not add a type to it ourselves. Pretty cool that ones line of code can do so much for us! The "Create" keyword is imperative, as it tells rails we are going to be making a new table. It then assumes the text following that will be the column names.

We might create an airport table next. Our planes will need to go somewhere, right? Just one more easy line of code like the above and we have another table ready to go. Now let's associate them through flights. As long as we have our foreign keys on the flight table from airplanes and airports, we'll be golden. Now, to do that, we could use a similar line like the above, but rails can do one better! It has specific syntax for when setting up a join table, which looks like this in this example:

  rails g migration CreateFlight number airplane:references 
  airport:references

Which would create this:

  class CreateFlight < ActiveRecord::Migration[6.0]
    def change
      create_table :flights do |t|
        t.string :number
        t.references :airplane, foreign_key: true
        t.references :airport, foreign_key: true
      end
    end
  end

Now with just a few lines of code, we have created 3 tables saving us time and ensuring we avoid simple bugs we may find if we tried typing this out ourselves. Thanks rails! We can also use the "Add" and "Remove" keywords to help quickly write migration files to add and remove columns where necessary.

Next we might want to add our models or our controllers. Rails has a generator for both of those! Just rails g model [model name] and rails g controller [controller name]. Now we could do these two separate commands for our airplanes, airports, and flight, or we could use a different shortcut: rails g resource [resource name]! With the simple line of rails g resource Airplane, rails will give us an airplane model, controller, view folder, and routes! Even more time saved and potential bugs avoided thanks to that good ol' rails magic.

There are more generators out there, but these are the ones I find myself using the most. To read more about rails generate, checkout the documentation here: https://guides.rubyonrails.org/command_line.html#rails-generate

Invocation Wizard

agandaur-ii — Fri, 13 Mar 2020 04:54:49 +0000

Going to be running with the "Rudy Wizard" idea from my last post this time. I had written about it before just as a funny aside, but the more I have been familiarizing myself with code jargon, the more I have been coming across the word "invocation". I was deeply steeped into the fantasy genre growing up so "invocation" is not a word I have seen tossed around recently. The connotations it brings up for me are quite different then what is being described to me in the steps to "invoke a method" or to "use an invocation operator", so I wanted to dig into the language and see how we got here.

Let's start with a good ol' dictionary definition.

invocation (n.)

the action of invoking something or someone for assistance or as an authority.
the summoning of a deity or the supernatural.
an incantation used to invoke a deity or the supernatural.

If we start looking at synonyms, it gets even further away from code associations:

bewitchment
charm
conjuration
enchantment
hex
incantation
spell

So right now I'm imagining all programers looking like this:

There are many stories of those using invocations to summon spirits or implore deities for blessings. The word appears in paganism, Christianity, voodooism, and many other religious and occult practices with references to invocations being found in cuneiform, Greek, and Egyptian, among others. A common thread, in most cases, is the summoning of something. Whether that be a demon, or a spirit, or a god, it was primarily an act of summoning something more powerful than yourself. So even though programing invocations aren't like this,

it's not too much of a stretch to imagine a programer calling on something more powerful than themselves, the computer, for assistance.

Even though doing this:

and doing this:

  function mathFunction(a, b) {
    return a + b;
  }

  mathFunction(4, 4);

don't feel quite the same today, a hundred years ago if you had told someone what a computer is capable of they might have also thought of it as witchcraft!

But let's move away from witchcraft and get on to the computer magic. Like the example above, invocation in code is quite easy. Once a function or method is created, you can simply call it later, or invoke it, to run the code you have provided it. And although our mathFunction above is simple, there are much more complicated invocations out there that really do seem to be magic. Think of the "book a plane ticket" invocation or "purchase home" invocation. These complex bits of code can lead to something special, unique, or unexpected all thanks to some binary artfully crafted on a computer.

In JavaScript, they even have something called an invocation operator. It's the "()" that is included whenever you are writing or invoking a function. This is where our expression or expressions will be placed that will correspond to an argument that can be used within the function itself. The invocation operator can include any number of expressions, including no expressions, but whenever that function is called the parenthesis must be present.

You can also invoke a function from within an object:

  var newObject = {
    firstName:"Harry",
    lastName: "Houdini",
    fullName: function () {
      return this.firstName + " " + this.lastName;
    }
  }

  newObject.fullName();

Our friend the invocation operator is still present in both the declaration of the function and the call of the function, but it is now part of an invocation chain off of the our object! First we invoke the object, and then the fullName function inside of it.

So the next time you get hung up on what you're doing or lose motivation, just remember that what your are doing might as well be magic.

A Little Rails Magic

agandaur-ii — Mon, 02 Mar 2020 08:13:19 +0000

Still new to the game here and loving how rails really makes your life just so much easier. I feel like I run into a lot of those moments while learning rails and find myself feeling like a wizard, as whatever rails is doing must be magic! Although it feels that way (and objectively would be much cooler if that was actually happening. I mean, how cool would it be to have your job title be "Ruby Wizard"!), rails is doing some pretty neat stuff in the background. I ran into the example below the other day and thought it would be beneficial to break down the magic so I can really understand whats going on so I can better utilize it in the future.

Let's start off with our schema:

create_table "pokemonabilities", force: :cascade do |t|
  t.integer "pokemon_id"
  t.integer "ablity_id"
end

create_table "pokemons", force: :cascade do |t|
  t.string "name"
  t.string "type"
end

create_table "abilities", force: :cascade do |t|
  t.string "name"
  t.string "description"
end

We've got a many-to-many relationship with Pokemon and abilities, so we have our join table to track those relationships. Once you have your models set up, the ActiveRecord relationships would look like this:

class Pokemon < ApplicationRecord
    has_many :pokemonabilities
    has_many :abilities, through: :pokemonabilities
end 

class Ability < ApplicationRecord
    has_many :pokemonabilities
    has_many :pokemons, through: :pokemonabilities
end

class Pokemonability < ApplicationRecord
    belongs_to :pokemon
    belongs_to :ability
end

All smooth sailing so far, but a small magic shoutout to rails being able to automatically change "ability" to "abilities" when necessary. Great, so we have our associations set up, so we can start making stuff. Better yet, let's have our users start making things. We can set up a basic controller that looks like this:

  def new
    @pokemon = Pokemon.new
  end

  def create  
      @pokemon = Pokemon.create(pokemon_params)
      redirect_to @pokemon
  end

  private

  def pokemon_params
      params.require(:pokemon).permit(:name, :type)
  end

Looking good. Now, let's create a form where our Pokemon-loving-users can create there very own Pokemon! We could start with something like this:

  <%= form_for @pokemon do |f| %>
      Name: <%= f.text_field :name %>
      Type: <%= f.text_field :type %>
      <%= f.submit %>
  <% end %>

Great! Now many fun new Pokemon can be born into the world. But now we have to go make something else to make sure these Pokemon have abilities. Why not just do it in the same form? We'll use the collection select function to give an easy list for our user to pick from. It's a pretty nifty option, which you can read more about here: https://guides.rubyonrails.org/form_helpers.html. And here's our new form:

  <%= form_for @pokemon do |f| %>
      Name: <%= f.text_field :name %>
      Type: <%= f.text_field :type %>
      Ability: <%= f.collection_select :ability_ids, Ability.all, :id, 
      :name%>
      <%= f.submit %>
  <% end %>

However, if we try to submit our form at this point, something odd happens. It will successfully create our new Pokemon, but it won't have any ability associated with it. What gives? Here is where the magic comes in! It comes down to updating our params. That is what the collection_select is giving us, so we just have to use it. Here's what the updated pokemon_params method will look like:

  def pokemon_params
      params.require(:pokemon).permit(:name, :type, :ability_ids)
  end

But if you are like me and got confused at this point, how on earth does just adding :ability_ids allow a Pokemon to be associated with those abilities? After all, we are passing our pokemon_params through our model to create a new instance, which looks essentially like this: Pokemon.create(:name, :type, :ability_ids). Name and type are present to make a Pokemon because that is how we set it up in our migration, but ability_ids aren't even on our Pokemon table. In fact, ability_ids doesn't show up on any of our tables, only ability_id. What's going on here?

Rails and ActiveRecord are doing something pretty cool here. When you create the new instance of a Pokemon, and passing in ability_ids, things are started to get checked in the background. When ability_ids is read, ActiveRecord is going to start checking "does this exist somewhere else?", since it recognizes it is not present on the Pokemon class. It will then check your associations to see if the value is present in a different class, and in this case, it will find that ability_id is associated with the Pokemonabilities class. Since it now has the Pokemon id and ability id, and we took the create action earlier, it creates a new instance of the Pokemonabilities class, which is now automatically associated with both our Pokemon and our chosen abilities!

Note that it is important, in the way these associations where set up, that you update your strong params to be the plural of the id you want to pass through. Even if you are only adding one ability at a time, since a Pokemon has the potential to have many abilities, ActiveRecord will be looking for a plural ids when creating things in this way.

So that's the magic! Although it is hopefully more clear how it's working in the background now, it's still fun to see how much work our app is doing for us so we can get on to more interesting things.

A reminder to myself, and possibly to others

agandaur-ii — Mon, 24 Feb 2020 21:33:43 +0000

Just passed the 4 week mark of bootcamp. Not the military kind, the software kind. I tried the military once but somehow ended up doing theatre instead--more on that later. Nonetheless, this is still a bootcamp and boy am I feeling it. I sometimes wish it was the crawling-through-mud-with-barbwire-above-you kind. There’s a clear goal there: get to the other side. In this bootcamp, sometimes I lose sight of what the other side is, so I have to remind myself often of why I am doing this. Part of that process is writing it down. If I have a place where my goal is visible, I can reference it, be reminded of it, and in the end, see how far I’ve come. So, still in the thick of barbwire, here we go.

Why did I decide to become a software engineer? I didn’t love my job before, but I liked it. The day to day was generally interesting, I greatly enjoyed the people I worked with, and I got to scooter into work everyday. Not a moped, not an electric scooter, but a good old fashioned Razor push scooter like it was 2000 again. Southern California has great weather for this kind of commuting, which I would highly recommend for those that are able. But with all that, I still checked the clock far too often while at work, like most people. Did my co-workers help? Immensely. How about the scooter? You bet. But after a number of years of primarily looking forward to being with my co-workers and getting to them via foot-powered childrens toys, I thought that maybe the job itself could be something I could look forward to. Maybe I would be at a job someday where I wasn’t just looking forward to that magical time of day when the two hands of the clock happen to be in the position that means “You can leave now.”

After a series of big life events, I find myself living in Seattle. Now I have no coworkers and no reasonable weather for riding my scooter (for the most part), so now I really am left with finding that job I could look forward to. Through another series of events and successful persuasion checks, I was lucky enough to have a friend from SoCal move up to the PNW. They just so happened to be a software engineer. During this combination of soul and job searching, they encouraged me to look into this whole coding thing. I have always had an interest in technology, but never really considered leveraging that as a career. I was a theatre major in college after all! I did try my hand at an Intro to CS class while in school, but it turned out to be the only class that I ever dropped. And I made it through a semester of ancient Greek translation, so that’s saying something. At that point, I was thoroughly convinced that computer science was not for me. I was discouraged, as I thought it would be something I would enjoy, and I always hoped I would come back to it one day. Well, that day came 4 weeks ago and I couldn’t be happier about it!

Even though I’ve only been coding for a short while, it has quickly become one of my favorite things to do. Very few things in my life really move time so fast that you lose track of how long you’ve been doing it. But I constantly find myself thinking, “That can’t be the time. Have I really been coding for that long??” and being completely fine with it. Strangely enough, my past theatre career has had a big influence on why I enjoy coding so much. At the end of the day, both mediums are about creation, and about building something from the ground up to proudly share with the world. With theatre, those creations are ephemeral. With coding, however, those creations are there forever (OK, I know, the internet is not forever, but you get what I mean). That different kind of creation is fascinating to me. The ability to continuously improve something is not commonplace in the theatrical world so I am very much looking forward to exploring that phenomenon as my software engineering career grows.

So that’s why I am here, to make a career out of this new passion of mine. I’ve got my goal post, my proverbial “end of the barbwire.” Even if it’s just me reading this in the future, whether that be next week, next month, or next year, now I know why I started. Now to see what comes next.