DEV Community: Brandon Weygant

Ruby Arrays Part II - Iteration

Brandon Weygant — Fri, 03 Jul 2020 19:09:06 +0000

What is Iteration?

Iteration is the repetition of a process. We've covered one form of iteration in an earlier lesson, but iteration also describes the manipulation of elements inside an array or hash. Fundamentally, there are 2 key differences between a loop and an iteration:

1. A loop will repeat an action a defined number of times, while an iteration works with a collection of data by allowing you to operate on each individual element.
2. Loops require a user-defined ending somewhere in the method or they will break your program with an infinite loop. Iterations could have a user-defined end if desired, but will cease after the last element in the collection has been iterated over otherwise.

You will do this thousands of times as a developer, and array manipulation is one of the core skills you will need to grow as a programmer. Fortunately in Ruby, if you exclude the loop methods like times & while, there are only 2 primary iteration methods you must learn - Each & Map.

How Iterators Compare to Loops

So aside from the two differences stated above, maybe you don't see the benefit to iterators and want to continue using loops. The best way to demonstrate the benefits of iterators is a direct comparison demonstration. Spoiler alert: Iterators will save you a lot of typing in the long run.

The first one will use the while loop:

nba_draft_top_10 = ["LaMelo Ball", "Onyeka Okongwu", "Anthony Edwards", "Killian Hayes", "James Wiseman", "Obi Toppin", "Tyrese Haliburton", "Aleksej Pokuseveski", "Cole Anthony", "Deni Avdija"]

i = 0
big_board = nba_draft_top_10.length

while i < big_board
    puts "#{nba_draft_top_10[i]} is one of the top rated prospects on my board."
    i+=1
end
#=>LaMelo Ball is one of the top rated prospects on my board.
#Onyeka Okongwu is one of the top rated prospects on my board.
#Anthony Edwards is one of the top rated prospects on my board.
#Killian Hayes is one of the top rated prospects on my board.
#James Wiseman is one of the top rated prospects on my board.
#Obi Toppin is one of the top rated prospects on my board.
#Tyrese Haliburton is one of the top rated prospects on my board.
#Aleksej Pokuseveski is one of the top rated prospects on my board.
#Cole Anthony is one of the top rated prospects on my board.
#Deni Avdija is one of the top rated prospects on my board.

Now lets see the same iteration using the each iterator:

nba_draft_top_10 = ["LaMelo Ball", "Onyeka Okongwu", "Anthony Edwards", "Killian Hayes", "James Wiseman", "Obi Toppin", "Tyrese Haliburton", "Aleksej Pokuseveski", "Cole Anthony", "Deni Avdija"]

nba_draft_top_10.each do |prospect|
    puts "#{prospect} is one of the top rated prospects on my board."
end

#=>LaMelo Ball is one of the top rated prospects on my board.
#Onyeka Okongwu is one of the top rated prospects on my board.
#Anthony Edwards is one of the top rated prospects on my board.
#Killian Hayes is one of the top rated prospects on my board.
#James Wiseman is one of the top rated prospects on my board.
#Obi Toppin is one of the top rated prospects on my board.
#Tyrese Haliburton is one of the top rated prospects on my board.
#Aleksej Pokuseveski is one of the top rated prospects on my board.
#Cole Anthony is one of the top rated prospects on my board.
#Deni Avdija is one of the top rated prospects on my board.

What took us 6 lines of code with a while loop took half that with an each iterator. There are a few keys to how this happens:

1. Because iterators understand array length inherently, there is no need to set a variable to establish a numerical value to it (big_board).
2. Iterators don't need counter variables (i) or conditions (i < big_board) to keep track when to stop.
3. Because of #2, you also have no need to manually increment your counter (i+=1).
4. As a bonus, the block provided by the each iterator provides us a more accessible and readable variable (prospect) than the while loop did (nba_draft_top_10[i]).

Take note that syntactically each and map are similar and you could switch them in the above example. So now that we've demonstrated the power behind iterators, let us break down each and map some more.

Each and Each's Extended Family

Each is an iterator designed to iterate through your array without mutating the original array. Let's open up an irb session and see what that means:

First we define the array.

irb(main):001:0> nba_draft_top_10 = ["LaMelo Ball", "Onyeka Okongwu", "Anthony Edwards", "Killian Hayes", "James Wiseman", "Obi Toppin", "Tyrese Haliburton", "Aleksej Pokuseveski", "Cole Anthony", "Deni Avdija"]

=> ["LaMelo Ball", "Onyeka Okongwu", "Anthony Edwards", "Killian Hayes", "James Wiseman", "Obi Toppin", "Tyrese Haliburton", "Aleksej Pokuseveski", "Cole Anthony", "Deni Avdija"]

Note that the implicit return is the entire array.

Now let's build our each method line by line.

irb(main):002:0> nba_draft_top_10.each do |prospect|
irb(main):003:1* puts "#{prospect} is going to be good value where he is picked."
irb(main):004:1> end
LaMelo Ball is going to be good value where he is picked.
Onyeka Okongwu is going to be good value where he is picked.
Anthony Edwards is going to be good value where he is picked.
Killian Hayes is going to be good value where he is picked.
James Wiseman is going to be good value where he is picked.
Obi Toppin is going to be good value where he is picked.
Tyrese Haliburton is going to be good value where he is picked.
Aleksej Pokuseveski is going to be good value where he is picked.
Cole Anthony is going to be good value where he is picked.
Deni Avdija is going to be good value where he is picked.

=> ["LaMelo Ball", "Onyeka Okongwu", "Anthony Edwards", "Killian Hayes", "James Wiseman", "Obi Toppin", "Tyrese Haliburton", "Aleksej Pokuseveski", "Cole Anthony", "Deni Avdija"]

Now notice how the iterator runs automatically after pressing 'enter'. But just as important, notice after the iterator finishes, it implicitly returns the original array. This is the purpose of each, to perform an action with a collection of data without mutating the original source.

There are actually several variations of each iterators like each_with_index, each_char, each_with_object and more. I will touch on each_with_index, but other each methods you should consult the Ruby Docs.

each_with_index will do the same thing as each, but takes a second argument inside the || block that will give a visible numerical value to the index. So if we wanted to turn our big board into rankings instead of a general top 10, we could do this:

nba_draft_top_10 = ["LaMelo Ball", "Onyeka Okongwu", "Anthony Edwards", "Killian Hayes", "James Wiseman", "Obi Toppin", "Tyrese Haliburton", "Aleksej Pokuseveski", "Cole Anthony", "Deni Avdija"]


nba_draft_top_10.each_with_index do |prospect, index|
    puts "I have #{prospect} rated ##{index+1} overall."
end

#=>I have LaMelo Ball rated #1 overall.
#I have Onyeka Okongwu rated #2 overall.
#I have Anthony Edwards rated #3 overall.
#I have Killian Hayes rated #4 overall.
#I have James Wiseman rated #5 overall.
#I have Obi Toppin rated #6 overall.
#I have Tyrese Haliburton rated #7 overall.
#I have Aleksej Pokuseveski rated #8 overall.
#I have Cole Anthony rated #9 overall.
#I have Deni Avdija rated #10 overall.

So in essence, the second argument in the block effectively substitutes for a counter variable & incrementer.

Also, James Wiseman is probably lower on my big board. I value Onyeka Okongwu's defensive versatility over Wiseman's more likely gaudy stats and think most others here will have a more well-rounded game.

Map & it's Perhaps Evil Twin Collect

So I know I mentioned there were 2 primary iterators, then snuck in that each has an extended family, but now I'm also adding a potentially evil twin? Yup, but I am exaggerating on the evil part. Map and collect are different names for basically doing the same thing: iterating through a collection and mutating that collection. I singled out collect as the evil twin for 2 reasons:

1. Mapis a more universal term for this action and is used in many programming languages.
2. Collect has more letters in it.

So let's open up a new irb session and use the same function we used with each:

irb(main):001:0> nba_draft_top_10 = ["LaMelo Ball", "Onyeka Okongwu", "Anthony Edwards", "Killian Hayes", "James Wiseman", "Obi Toppin", "Tyrese Haliburton", "Aleksej Pokuseveski", "Cole Anthony", "Deni Avdija"]

=> ["LaMelo Ball", "Onyeka Okongwu", "Anthony Edwards", "Killian Hayes", "James Wiseman", "Obi Toppin", "Tyrese Haliburton", "Aleksej Pokuseveski", "Cole Anthony", "Deni Avdija"]
irb(main):002:0> nba_draft_top_10.map do |prospect|
irb(main):003:1* puts "#{prospect} is going to be good value where he is picked."
irb(main):004:1> end
LaMelo Ball is going to be good value where he is picked.
Onyeka Okongwu is going to be good value where he is picked.
Anthony Edwards is going to be good value where he is picked.
Killian Hayes is going to be good value where he is picked.
James Wiseman is going to be good value where he is picked.
Obi Toppin is going to be good value where he is picked.
Tyrese Haliburton is going to be good value where he is picked.
Aleksej Pokuseveski is going to be good value where he is picked.
Cole Anthony is going to be good value where he is picked.
Deni Avdija is going to be good value where he is picked.

=> [nil, nil, nil, nil, nil, nil, nil, nil, nil, nil]

Check out the implicit return. See how we are now returning nil where we used to return prospect names? Well, it returns nil due to a combination of map mutating the array and puts is inherently nil. If we want to see the changes reflected, we just have to remove the puts.

irb(main):005:0> nba_draft_top_10.map do |prospect|
irb(main):006:1* "#{prospect} is going to be good value where he is picked."
irb(main):007:1> end
=> ["LaMelo Ball is going to be good value where he is picked.", "Onyeka Okongwu is going to be good value where he is picked.", "Anthony Edwards is going to be good value where he is picked.", "Killian Hayes is going to be good value where he is picked.", "James Wiseman is going to be good value where he is picked.", "Obi Toppin is going to be good value where he is picked.", "Tyrese Haliburton is going to be good value where he is picked.", "Aleksej Pokuseveski is going to be good value where he is picked.", "Cole Anthony is going to be good value where he is picked.", "Deni Avdija is going to be good value where he is picked."]

Now we see something really interesting. We no longer have the puts command to display our function item by item like in previous examples. Instead, we definitively see the mutations we made to the array reflected in a new array produced by the map iterator that contains all the returned values.

For good measure, here is that same iteration using collect:

irb(main):008:0> nba_draft_top_10.collect do |prospect|
irb(main):009:1* "#{prospect} is going to be good value where he is picked."
irb(main):010:1> end
=> ["LaMelo Ball is going to be good value where he is picked.", "Onyeka Okongwu is going to be good value where he is picked.", "Anthony Edwards is going to be good value where he is picked.", "Killian Hayes is going to be good value where he is picked.", "James Wiseman is going to be good value where he is picked.", "Obi Toppin is going to be good value where he is picked.", "Tyrese Haliburton is going to be good value where he is picked.", "Aleksej Pokuseveski is going to be good value where he is picked.", "Cole Anthony is going to be good value where he is picked.", "Deni Avdija is going to be good value where he is picked."]

Zero discernable differences.

Mutable vs Immutable

Since mutation is the key difference with these iterators, it's probably best if we touch on what situations to use each. I'm hardly the best to explain, I did find a really good article here, though it covers JavaScript uses the principle will remain the same. Now for most of what you will do while you are starting out, functionally, there will be little difference between mutable and immutable iterations. However, when you start building more complex apps, this nuance becomes more important. This is an over-generalization to be sure, but here it is:

1. Use each when you are iterating through your back-end data. This is the stuff that you wouldn't want to permanently manipulate as it could affect other parts of your app. When using Ruby on Rails, your Controllers are a good example of places you want to use each.
2. Use map to iterate and manipulate data you want the user to see (front-end). Map is often less bulky code-wise to work with since it naturally preserves itself by returning a new array.

Ruby Iterations Lab

Let's go collect some practice to help map out each of our skills in the Ruby Iterations Lab!

Question: Rails 6 App with Devise/Omniauth on Heroku?

Brandon Weygant — Fri, 26 Jun 2020 15:15:47 +0000

So I've been stuck on this for some time now and was wondering if anyone here has any insight that can help me. For the most part the app works on the site, but there are two known issues I can't seem to resolve on my own:

1) Password recovery doesn't work, not actually sure if this is all on devise or if I needed an outside mail campaign to do this.
2) Can't login using the Github omniauth link. The primary issue was the page didn't exist and it took me down this rabbit hole where i hardly recognize or understand what my devise controllers and configuration or supposed to be doing anymore.

Check out the project here

Forgive the ugliness of the site, swear I got some styling planned. I just can't focus on that stuff while I got technical issues like this.

Ruby Arrays

Brandon Weygant — Thu, 18 Jun 2020 17:17:49 +0000

This week we'll be diving deeper into Arrays in Ruby. We touched a bit on them in a previous lesson about Ruby classes, and this time we'll cover them more in depth and demonstrate why they are such a useful programming tool.

Array Recap

An array is a collection of data stored in list form for your program to access. It is denoted with opening and closing brackets ([]). A couple of examples of arrays are as follows:

numbers_array = [1, 2, 3, 4, 5]
#This is an array of 5 different Integers.

words_array = ["words", "to", "fill", "this", "array"]
#This is an array of 5 different Strings.

single_array = ["this, looks, like, a, lot, of, different, words, but, a, syntax, error, makes, this, a, one, string, array"]
#This is an array with only 1 String.

You can also declare an empty array in 2 different ways, one like above and the other via the class constructor:

my_array = []
#=> []
#Nice and simple

my_array = Array.new
#=> []
#Same result and a bit more typing.

And that's it, no tricky syntax or creation method. You create an array in the exact same way you would create a varaible in Ruby. As a matter of fact, when declaring an array, think of it as a short cut for declaring multiple variables at one time. An array is a very convenient storage container for a programmer to help keep their program clean and organized.

Array's are indexed starting with the number 0. This means the first element in each array will be called with the syntax array_name[0], the second element array_name[1], and so forth. Keep this little detail in mind as you build programs, or your neat little organizational tool will become a serious headache very quickly.

numbers_array = [1, 2, 3, 4, 5]
#An array of 5 elements.

puts numbers_array[0]
#=> 1

puts numbers_array[2]
#=> 3

puts numbers_array[5]
#=> nil

One more thing about array indexes. While 0->1->2->etc will move forward from the first element in an array, you can also start from the very end of an array using negative numbers. When doing this the number -1 will always be assigned as the last element in an array, -2 the second to last element, and the first element will have the same negative number as the length of the array.

numbers_array = [1, 2, 3, 4, 5]
#An array of 5 elements.

puts numbers_array[0]
#=> 1

puts numbers_array[-1]
#=> 5

puts numbers_array[-3]
#=> 3
puts numbers_array[-5]
#=> 0 (in our previous example an index of positive 5 returned nil)

Remember negative indexes start at -1 and not zero.

Array Methods

So we can see the value and ease of use of an array vs declaring all those separate variables. But what if you wanted to add or subtract another element to the array? You could just add or subtract from the array directly for permanent global changes, but what if you only wanted to add or remove an element is more specific cases? What if you want to know how many elements are in an array? Do you want to count each one by hand? No, you do not. Luckily Ruby comes ready to rock with many helpful methods specifically catered to arrays!

You can view all the possible methods usable on an array with the methods method as such:

C:\Users\Brandon>irb
irb(main):001:0> my_array = [1, 2, 3, 4]
=> [1, 2, 3, 4]
irb(main):002:0> my_array.methods
=> [:to_h, :include?, :at, :fetch, :last, :union, :difference, :push, :append, :pop, :shift, :unshift, :each_index, :join, :rotate, :rotate!, :sort!, :sort_by!, :collect!, :map!, :select!, :filter!, :keep_if, :values_at, :delete_at, :delete_if, :reject!, :transpose, :fill, :assoc, :rassoc, :uniq!, :compact, :*, :+, :flatten!, :&, :shuffle, :sample, :compact!, :flatten, :combination, :shuffle!, :-, :repeated_permutation, :sort, :product, :bsearch, :repeated_combination, :count, :find_index, :select, :filter, :reject, :collect, :map, :permutation, :first, :all?, :bsearch_index, :any?, :none?, :one?, :reverse_each, :zip, :take, :take_while, :drop, :drop_while, :cycle, :sum, :uniq, :|, :insert, :<=>, :<<, :index, :rindex, :replace, :==, :clear, :pack, :[], :[]=, :empty?, :eql?, :max, :min, :reverse, :inspect, :concat, :prepend, :reverse!, :length, :size, :each, :to_ary, :delete, :to_a, :to_s, :slice, :slice!, :dig, :hash, :to_set, :find, :entries, :sort_by, :grep, :grep_v, :detect, :find_all, :flat_map, :collect_concat, :inject, :reduce, :partition, :group_by, :minmax, :min_by, :max_by, :minmax_by, :member?, :each_with_index, :each_entry, :each_slice, :each_cons, :each_with_object, :chunk, :slice_before, :slice_after, :slice_when, :chunk_while, :lazy, :chain, :instance_variable_defined?, :remove_instance_variable, :instance_of?, :kind_of?, :is_a?, :tap, :methods, :singleton_methods, :protected_methods, :instance_variables, :instance_variable_get, :instance_variable_set, :private_methods, :public_methods, :method, :singleton_method, :public_send, :public_method, :define_singleton_method, :extend, :to_enum, :enum_for, :===, :=~, :!~, :respond_to?, :freeze, :object_id, :send, :display, :nil?, :class, :singleton_class, :clone, :dup, :itself, :yield_self, :then, :taint, :tainted?, :untaint, :trust, :frozen?, :untrust, :untrusted?, :equal?, :!, :__id__, :instance_exec, :!=, :instance_eval, :__send__]
irb(main):003:0>

That's a ton of methods! Granted not all are array specific, but we'll sort out some of the most popular and need to know ones here.

Basic Array Methods

These are some of the methods to gather information about your array.

inspect - This method returns a string version of the array containing all the current elements inside of it.

C:\Users\Brandon>irb
irb(main):001:0> my_array = [1, 2, 3, 4]
=> [1, 2, 3, 4]
irb(main):002:0> my_array.inspect
=> "[1, 2, 3, 4]"
irb(main):003:0>

length - This method returns the number of elements currently in an array. This method will be frequently used in a ton of programming math and troubleshooting, so it's best to familiarize yourself with it quickly.

C:\Users\Brandon>irb
irb(main):001:0> my_array = [1, 2, 3, 4]
=> [1, 2, 3, 4]
irb(main):002:0> my_array.inspect
=> "[1, 2, 3, 4]"
irb(main):003:0> my_array.length
=> 4
irb(main):004:0>

index - This method will return the index number of the first occurrence of its given argument.

C:\Users\Brandon>irb
irb(main):001:0> my_array = [1, 1, 2, 3, 4]
=> [1, 1, 2, 3, 4]
irb(main):002:0> my_array.index(1)
=> 0
irb(main):003:0>

Note we only get '0' as the index even though we have multiple '1's in the array. You probably won't be performing this very often, but can be useful in a pinch in larger arrays to quickly identify an index number when needed.

first & last - These methods will return the value of the first or last element in an array.

C:\Users\Brandon>irb
irb(main):001:0> my_array = [1, 2, 3, 4]
=> [1, 2, 3, 4]
irb(main):002:0> my_array.first
=> 1
irb(main):003:0> my_array.last
=> 4
irb(main):004:0>

sort - A method that will sort your array. By default, it will sort in ascending order (lowest to highest).

my_array = [3, 1, 4, 2]

print my_array.sort
#=> [1, 2, 3, 4]
#We used print to see the return in array form.

reverse - As the name implies, this will reverse your array.

my_array = [1, 2, 3, 4]

print my_array.reverse
#=> [4, 3, 2, 1]

Adding and Removing Elements

Arrays come with several methods to quickly manipulate the number of elements in them.

<< (AKA The Shovel Operator) - The shovel operator will add an element to the end of an existing array very painlessly. It is the preferred method to add items to an array due to it's simplicity, though there are other methods you must use if you need something injected elsewhere into an array.

C:\Users\Brandon>irb
irb(main):001:0> my_array = [1, 2, 3, 4]
=> [1, 2, 3, 4]
irb(main):002:0> my_array << 5
=> [1, 2, 3, 4, 5]
irb(main):003:0>

push - This method is the longer equivalent of the << operator. It add's a new item to the end of the array.

C:\Users\Brandon>irb
irb(main):001:0> my_array = [1, 2, 3, 4]
=> [1, 2, 3, 4]
irb(main):002:0> my_array.push(5)
=> [1, 2, 3, 4, 5]
irb(main):003:0>

unshift - This method will add an element to the front of an array. Not as common as << or push but more often than not you will be manipulating either the first or last element in an array so it's good to keep this one in mind.

C:\Users\Brandon>irb
irb(main):001:0> my_array = [1, 2, 3, 4]
=> [1, 2, 3, 4]
irb(main):002:0> my_array.unshift(0)
=> [0, 1, 2, 3, 4]
irb(main):003:0>

pop - This method will remove the last element from an array and return it.

C:\Users\Brandon>irb
irb(main):001:0> my_array = [1, 2, 3, 4]
=> [1, 2, 3, 4]
irb(main):002:0> my_array.pop
=> 3
irb(main):003:0>

shift - This method will remove the first element in an array and returns it.

C:\Users\Brandon>irb
irb(main):001:0> my_array = [1, 2, 3, 4]
=> [1, 2, 3, 4]
irb(main):002:0> my_array.shift
=> 1
irb(main):003:0>

Note: With unshift & push you have to pass the value of the element you wish to add as an argument, but since pop & shift are removing already known elements no argument is necessary.

delete_at- This method will remove an element at a specific index. Rarely used, but it's good to know if you ever find yourself needing to add an element into the middle of an array for whatever reason.

C:\Users\Brandon>irb
irb(main):001:0> my_array = [1, 2, 3, 4]
=> [1, 2, 3, 4]
irb(main):002:0> my_array.delete_at(2)
=> 3
irb(main):003:0>my_array
=> [1, 2, 4]
irb(main):004:0>

insert - This method adds an element to an array at a specific index. It takes 2+ arguments, the first is the index you want to start the insert at, and the second (and possibly more arguments) are the elements you want to add.

C:\Users\Brandon>irb
irb(main):001:0> my_array = ["All", "Lives", "matter", "yours", "too!"]
=> ["All", "Lives", "matter", "yours", "too!"]

In this array we a very true an encouraging sentiment, but it doesn't quite capture our feelings. We can start by removing the "yours" element with delete_at.
Note, arrays are not great sentence constructors!

irb(main):002:0> my_array.delete_at(3)
=> "yours"
#=> ["All", "Lives", "matter", "too!"]

Now let's add a few more words with insert.

irb(main):003:0> my_array.insert(2, "can't")
=> ["All", "Lives", "can't", "matter", "too!"]

We've definitely changed the sentiment here, and not for the better. Let's fix it with another insert.

irb(main):004:0> my_array.insert(4, "until", "Black", "Lives", "Matter")
=> ["All", "Lives", "can't", "matter", "until", "Black", "Lives", "Matter", "too!"]

Perfect!

Conclusion

This is a very long blog post, and with good reason! Arrays are a major part of programming, and there is a ton of ground to cover. Quite simply there is absolutely no way out of a ton of reading and research on this subject. A good example will be next week when we cover part two, array iteration where we introduce even more array methods!

Ruby Arrays Lab

You guessed it, another lab! Let's drive these lesson home with a little practice. Complete the Ruby Array Methods Lab.

Ruby IRB

Brandon Weygant — Tue, 02 Jun 2020 18:18:26 +0000

I'm not in such a good enough mood to go and write this with as much attention as it deserves with everything going on in this country right now. A lot of hurt is happening, and a lot of change is necessary.

Anyways, here's a short intro on Ruby's irb command line. This is a useful tool for practicing Ruby and trying new concepts as well ass different tricks.

What is IRB?

IRB - short for "Interactive Ruby" - is a tool to interactively execute Ruby expressions read from the standard input. It's as easy to start an IRB session as typing irb in your shell after installing Ruby.

C:\users\Brandon>irb
irb(main):001:0>

Something like irb(main):001:0> above should appear with the '_' flashing. This means you have successfully entered an irb session.

What Can You Do Inside A Session?

IRB is designed to be a temporary session that you can terminate whenever your ready to start actual work. It's main purpose is to provide a safe place to practice without actually interfering with you program. For example, you can declare a variable like you would in any ruby program:

C:\users\Brandon>irb
irb(main):001:0> x = "Black Lives Matter"
=> "Black Lives Matter"
irb(main):002:0>

You can call the variable any time during your session before you close it simply by typing the variable and pressing enter:

irb(main):002:0> x
=> "Black Lives Matter"
irb(main):003:0>

You can also build functions in irb. This is a bit clunky, as it is designed to be done line by line like this:

b(main):001:0> def injustice
irb(main):002:1> puts "George Floyd, Natosha McDade, Yassin Mohamed, Finan H. Berhe, Sean Reed, Steven Demarco Taylor, Breonna Taylor, Ariane McCree, Terrance Franklin, Miles Hall, Darius Tarver, William Green, Samuel David Mallard, Kwame Jones, Devon Bailey, Christopher Whitfield, Anthony Hill, DeVon Bailey, Eric Logan, Jamarion Robinson, Gregory Hill Jr, JaQuavion Slaton, Ryan Twyman, Brandon Webber, Jimmy Atchison, Willie McCoy, Emantic Fitzgerald Bradford J, Dettrick Griffin, Jemel Roberson, DeAndre Ballard, Botham Shem Jean, Robert Lawrence White, Anthony Lamar Smith, Ramarley Graham, Manuel Loggins Jr, Trayvon Martin, Wendell Allen, Kendrec McDade, Larry Jackson Jr, Jonathan Ferrell, Jordan Baker, Victor White III, Dontre Hamilton, Eric Garner, John Crawford III, Michael Brown, Ezell Ford, Dante Parker, Kajieme Powell, Laquan McDonald, Akai Gurley, Tamir Rice, Rumain Brisbon, Jerame Reid, Charly Keunang, Tony Robinson, Walter Scott, Freddie Gray, Brendon Glenn, Samuel DuBose, Christian Taylor, Jamar Clark, Mario Woods, Quintonio LeGrier, Gregory Gunn, Akiel Denkins, Alton Sterling, Philando Castile, Terrence Sterling, Terence Crutcher, Keith Lamont Scott, Alfred Olango, Jordan Edwards, Stephon Clark, Danny Ray Thomas, DeJuan Guillory, Patrick Harmon, Jonathan Hart, Maurice Granton, Julius Johnson, Jamee Johnson, Michael Dean, and many, many, many others."
irb(main):003:1> end
=> :injustice

And just like with variables we can call that function anytime during our session by typing it in the shell:

irb(main):004:0> injustice
George Floyd, Natosha McDade, Yassin Mohamed, Finan H. Berhe, Sean Reed, Steven Demarco Taylor, Breonna Taylor, Ariane McCree, Terrance Franklin, Miles Hall, Darius Tarver, William Green, Samuel David Mallard, Kwame Jones, Devon Bailey, Christopher Whitfield, Anthony Hill, DeVon Bailey, Eric Logan, Jamarion Robinson, Gregory Hill Jr, JaQuavion Slaton, Ryan Twyman, Brandon Webber, Jimmy Atchison, Willie McCoy, Emantic Fitzgerald Bradford J, Dettrick Griffin, Jemel Roberson, DeAndre Ballard, Botham Shem Jean, Robert Lawrence White, Anthony Lamar Smith, Ramarley Graham, Manuel Loggins Jr, Trayvon Martin, Wendell Allen, Kendrec McDade, Larry Jackson Jr, Jonathan Ferrell, Jordan Baker, Victor White III, Dontre Hamilton, Eric Garner, John Crawford III, Michael Brown, Ezell Ford, Dante Parker, Kajieme Powell, Laquan McDonald, Akai Gurley, Tamir Rice, Rumain Brisbon, Jerame Reid, Charly Keunang, Tony Robinson, Walter Scott, Freddie Gray, Brendon Glenn, Samuel DuBose, Christian Taylor, Jamar Clark, Mario Woods, Quintonio LeGrier, Gregory Gunn, Akiel Denkins, Alton Sterling, Philando Castile, Terrence Sterling, Terence Crutcher, Keith Lamont Scott, Alfred Olango, Jordan Edwards, Stephon Clark, Danny Ray Thomas, DeJuan Guillory, Patrick Harmon, Jonathan Hart, Maurice Granton, Julius Johnson, Jamee Johnson, Michael Dean, and many, many, many others.
=> nil

Don't mind the nil return, its just how it works behind the scenes. The important thing is that we did get the return we were expecting. Functions are clunky as you can see in irb, and it's not the ideal environment (especially if you have complex functions), but it is a good place to work out any kinks or fears you have about functions.

You can end the irb session by typing exit:

irb(main):011:0> exit

C:\users\Brandon>

There is a ton more, like creating new instances of a class - including custom classes. Really, outside of the sometimes clunky interface, irb doesn't have many limitations to what you can't do with Ruby. The important thing to remember is it is a practice tool, and when you terminate the sessions you lose the data you inputted.

Stay safe out there.

Ruby Data Type Classes: Numbers, Arrays, Symbols, & Hashes

Brandon Weygant — Mon, 25 May 2020 19:29:07 +0000

Before we dive deeper into some more of the basics of Ruby, I felt it necessary to explain more about classes. We'll discuss the different classes above, and give some light examples this week, before diving more in-depth in our following lessons. If you think classes sound a little advanced for you, fear not! We've already covered a few classes in previous lessons: the String class & the Boolean classes TrueClass & FalseClass. EZPZ!

What is a Class?

In Ruby, a class is basically the blueprint for building an object. While Ruby provides you the freedom to define your own classes (covered in a later lesson), the classes we will be discussing are the basic classes that already come built into Ruby. The main ones we will cover (in addition to the ones we already have) are:

TrueClass & FalseClass - Creates an instance of a `true` or `false` object.
String Class - A string is a sequence of characters, denoted in programming with quotation marks.
Number Classes - "Number" is not a class itself, but is a reference to several number-based classes.
Array Class - An array is an ordered, integer-indexed collection of any objects.
Symbol class - Symbols are generally used to identify a specific resource such as a method, variable, hash key, etc.
Hash Class - A collection of `keys` and their `values`.

The benefits of being a part of a class in Ruby, is that each class provides the blueprint as well as various built-in methods that every instance of that class will have access to. When dealing with a certain data type, you can use the methods method to view what methods are available to you for that data type. For instance:

x = "Hello, world!"
#x would be an instance of String class

puts x.methods
#=> to_h
#=>include?
#=>at
#=>fetch
#=>last
#=>union
#=>difference
#=>push
#=>...

#Lists all String class methods

Whereas

x = 1
#x would be an instance of Integer class

puts x.methods
#=> -@
#=> **
#=> <=>
#=> upto
#=> <<
#=> <=
#=> >=
#=> ==
#=>...

#Lists all Integer class methods

You can see from the list we have different methods available to x depending on what class its value is classified as. Knowing what methods are available to you is paramount as a developer.

Numbers Classes

Ruby uses quite a few different classes for numbers, each one meant to capture certain unique features different types of numbers could have. Numbers can become a very hefty topic very quickly, so I'll keep it quick and only mention Integer and Float classes, as those are by far the most frequent you will be using.

Integer Class

The Integer class is simple and straightforward: it holds whole numbers. Anything with a decimal, fraction, or some other demarkation of partial value does not fit into the Integer class.

Float Class

Used to identify decimal numbers. Pi would be an example of a Float class instance.

puts Math::PI.class 
#=> Float

On a side note, when using math in Ruby such as 1/2 (the / stands for 'divided by' in Ruby), by default Ruby will try to force the solution to be an an Integer since both the dividend and divisor fall under the Integer class. By contrast, 1.5/3 would naturally fall under the Float class since 1.5 is a Float. When using math in Ruby with whole numbers that could lead to a decimal value, it's good practice to convert to float with the .to_f method to prevent Ruby from rounding to the nearest Integer.

x = 1/2

puts x 
puts x.class

#=> 0
#=> Integer

y = 1/2.to_f

puts y 
puts y.class

#=> 0.5
#=> Float

Array Class

As stated earlier, an array is an ordered, integer-indexed collection of any objects. You would denote an array in Ruby with brackets []. You separate each object in an array with a ,. A few examples of an array are:

numbers_array = [1, 2, 3, 4, 5]
#This is an array of 5 different Integers.

words_array = ["words", "to", "fill", "this", "array"]
#This is an array of 5 different Strings.

single_array = ["this, looks, like, a, lot, of, different, words, but, a, syntax, error, makes, this, a, one, string, array"]
#This is an array with only 1 String.

You can immediately see the value in arrays as storage containers. An array can give us access to multiple objects in a single location!

Arrays are indexed in order starting with 0. This means that the first object in an array will have an index number of 0, the second an index of 1, and so on. You can access a specific index in an array with the syntax array_name[index#]. Using the arrays above, try to guess the return value of numbers_array[2], single_array[1], words_array[0].

If you guessed numbers_array[2] = 3,single_array[1]=nil(means 'nothing'), &words_array[0] = words you were right. Anything else means you were less right :).

Comparing the above to our earlier lesson on variables, In addition to storing data in list form, think of the index number as also setting a variable to all the different pieces of data inside an array.

Symbol Class

Symbols generally point to a specific resource in your program. You denote them in ruby with a : in front of the word you want as a symbol like :brandon. The key benefit of using symbols is that they are immutable and will always point to the same object. By comparison, a string even if totally identical, will always be a different object and take up more memory to account for mutability. The most basic way to understand this is to return multiple of the same data type with equal value:

puts "Brandon".object_id
puts "Brandon".object_id
puts "Brandon".object_id
#=> 42553140
#=> 42552980
#=> 42552920

Note how all the object_id's are different.

Now the same thing but using the Symbol :brandon

puts :brandon.object_id
puts :brandon.object_id
puts :brandon.object_id
#=> 1102428
#=> 1102428
#=> 1102428

Now all the id's are the same. This immutability is primarily why symbols make superior hash keys because they will point to the same value without using as much memory, hence making your program less bulky overall. More on Hash class right below, but note the two ways to make a symbol into a hash key:

instructor = {:name => "Brandon Weygant"}

This first way is the native way to do it in Ruby. However, as of Ruby 1.9 and above, they simplified the syntax to make it look like a more classical key:value pairing like this:

instructor = {name: "Brandon Weygant"}

name: will still read as a Symbol in this case, and this syntax is the preferable way to do it today. Note that if you use keys that aren't symbols inside a hash, you will have to continue to use the => rocket syntax.

Hash Class

As stated earlier, a Hash is a collection of keys and their values. A hash is denoted with the curly brackets {}. Inside the {} you would have a key pointing to a value (like above in Symbols) and multiple entries would be separated with comma's, just like in arrays

A Hash has many similarities to an Array, but some key differences as well. Where an array is a list, hashes are dictionaries where we look up the value of a key by using the key directly. This means you aren't bound by knowing what index# an array list item has to call it, you simply have to remember the key you used. Example:

todays_lessons = {number: "We learned about number classes.", 
    array: "We learned about number classes.", 
    symbol: "We learned about the Symbol class.", 
    hash: "We are currently learning about the hash class!"}

If we tried to puts todays_lessons[1], instead of getting the :array value, we'd get nil instead. The correct syntax to return the :array value is:

puts todays_lessons[:array]

Amazingly simple, right? If an Array is designed to be a list of your classes, a hash could be used as an equivalent to the notes you took while in class.

Conclusion

This is a lot to unpack in a day, but the basics taught here will be vital to understanding as we dive deeper into Math, Array manipulation, iteration, and Hashes. There is a ton of information we haven't covered on each of these. I just hope this gives you a general idea of how Ruby uses different classes to organize and enhance the unique properties each data type brings to the table.

For now take a break and happy Memorial Day!.

Ruby Data Types Lab

We've unpacked a lot in this lesson, covering several data types you may or may not already be familiar with. Let's embed that by completing the tasks found in the Ruby Data Types Lab!

Ruby Loops

Brandon Weygant — Wed, 20 May 2020 21:49:40 +0000

Today we're going to go over the concept of looping in Ruby. Looping is an action that tells our program to do the same thing over and over again with a few lines, rather than manually typing out our desired loop length.

Why Loop?

Simple answer: because as programmers we aspire to be as lazy as possible.

Think a minute about writing a program that requires you to perform an action 5 times, then imagine having to do it 100 times. What problems could you potentially run into typing all occurrences manually? First is a matter of convenience, even if you copy/paste to ensure all the lines are exactly the same, that's still a tedious manual task that takes away time from improving your program elsewhere. Next, what if you lose count after say 47? What if you accidentally type it in only 97 times? 103 times? This could potentially cause your program to not work as intended in other parts of your code as well.

Loops automate this process for us with only a couple lines of code in Ruby. A program that would require a String to be repeated 100x would use 100+ lines of code if manually looped. You can perform the same functionality in Ruby with about 3 lines of code:

100.times do
  puts "Here we go 'round!"
end

And just like that, a seemingly daunting task is complete in a matter of seconds!

Ruby has several different types of loops, some with overlapping functionality and some meant to be more niche in use. We'll go over some of the more common types of loops and explain them in greater detail below.

Times Loops

Let's start by breaking down the above loop, and highlight the keys that make this function:

100.times do
  puts "Here we go 'round!"
end

100.times is the number of times we want our program to perform the following action. The number in front of times also serves as a built-in break of the loop, where some other loop types require you to add it in elsewhere.
the do/end creates a block that tells our program what action we want to perform. In this case puts "Here we go 'round!" The do/end block will be a common participant in a number of Ruby lessons.

The beauty of Ruby is it's designed with being programmer-friendly as it's #1 priority. times is one of the best examples of that in the entire language.

The "Loop" Keyword

Next up is the loop keyword. loop is the simplest construct we have for looping in Ruby. It will just execute a block (the action(s) between do/end) over and over until it is told to stop.

Let's built a similar method as above from scratch:

loop do
  puts "Here we go 'round!"
end

This will put the string "Here we go 'round!" into our console in an eternal loop until we stop it with ctrl+c. Not terribly useful overall in its current form if you ask me. Let's add a break command to stop the loop on its own:

loop do
  puts "Here we go 'round!"
break
end

# returns =>
#Here we go 'round!

So now we have a "loop" that only executes our desired command once. The thing is loop is so simple, that it requires a bit more effort to work at the same level as times, which kind of defeats the point as Rubyists.

If we wanted to write a loop command equivalent to our times command above, we would have to add a counter to keep track of when to break the loop like such:

counter = 0
loop do
    counter += 1
    puts "Here we go 'round!"
    if counter >= 100
        break
    end
end

That is almost triple the number of lines it took our times loop to accomplish the same task.

Note You may be wondering what the += is doing. It basically performs the same function as the line counter = counter + 1 which increments and keeps track of the updated value of the counter variable. It simply condenses the code.

Since we have a counter variable, I'll take this opportunity to demonstrate how to keep track of variables inside loops. Stop me if this looks familiar to you:

counter = 0
loop do
    counter += 1
    puts "Here we go 'round #{counter} times!"
    if counter >= 100
        break
    end
end
#returns =>
#Here we go 'round 1 times!
#Here we go 'round 2 times!
#...
#Here we go 'round 99 times!
#Here we go 'round 100 times!

Yup, we can interpolate with #{variable} inside loops to display and even manipulate the current values of variables.

While Loops

while loops provide a unique approach to a similar end. Basically while translates the given condition to a boolean, and if that condition is true the while loop will then execute until the condition is false. Like times while is it's own built-in break, so there is no need to declare a direct break inside the action like with loop. Writing a loop like above in this style would look like this:

counter = 0
while counter < 100
  puts "Here we go 'round!"
counter += 1
end

Removing the break command saves us some space, but in a strict counting situation while still isn't as advantageous as the times loop. However, in slightly more complex programs, while has some strong advantages over times. For example, if we had an adventurer who was poisoned and losing health, we would want to keep track of our HP so we know when to use our auto-revive potions, right? And we would definitely need a reminder to pop up when we died from the poison too, right?

hp = 100
status = "poisoned"
potions = 2

while status == "poisoned" && hp >= 1
    hp -= 1
    puts "HP: #{hp}"
    if hp == 0 && potions >= 1
        puts "You've used an auto-revive potion!"
        potions -= 1
        hp += 100
        status = "normal"
        puts "HP: #{hp}"
    elsif hp == 0 && potions == 0
        puts "The poison was too much to bear!"
    end
end

This code is a bit busy, but doesn't contain anything we haven't covered already! The gist is we set initial values for hp, status. & potions and manipulated them throughout the while loop. Using times in this situation would require multiple loops and more lines for what would likely be a less desirable result. Also note the do in while is not necessary

On a more personal note, I'm glad we had enough potions to survive being poisoned!

Until Loops

unitl is basically the inverse of while. Where a while loop executes when something is true, an unitl loop will execute until something becomes true. For example:

counter = 0
until counter == 20
  puts "Almost 20!"
  counter += 1
end

Just like while the do is optional.

While you can do complex code with until, in my opinion, the best time to use until is as a statement modifier. Example:

i = 0
puts i += 1 until i == 5

#returns =>
#1
#2
#3
#4
#5

This is a very simple example, but it does an effective job of manipulating the value of a variable to the desired number in only 1 line of easy to read code.

Concluison

The key to loops in Ruby, and any programming language really, is knowing what loop is best used in a given situation. Do you want to repeat an action a specific amount of times with little additional context? Use times!. Want to drown someone special in your eternal love? Use loop (with no break!)! Wanna get a little more complex with your code? Use while! Need a simple and precise statement modifier? Use until!

Loops Lab

Now that you've learned about Loops, let's head on over to the Ruby Loops Lab and apply those lessons by completing the assigned tasks.

Ruby Methods

Brandon Weygant — Tue, 12 May 2020 20:54:50 +0000

In previous lessons, we discussed variables and logic in Ruby. Today we're going to discuss methods, what they are, and how to define them among other things.

What are Methods in Ruby?

Methods are simply instructions for your program to follow when the method is called. If you compare the variables we learned about before to 'nouns', you could make the analogy methods are 'verbs'.

The power of methods is only limited by one thing: the creator's imagination...ok there are some technical limits as well, but you get me. They are powerful tools that allow you to customize and optimize your program to whatever means you seem fit.

Probably the largest benefit to methods is the ability to store the action for later use. Unlike the types of variables and conditionals we used earlier, which run each time we run our program, methods will only run when they are called somewhere inside the program.

An example of a method could be our "Sam Sees Ghost" example from an earlier lesson. Turning this into a method is as easy as wrapping our code in the def (short for define) & end keywords like so:

def seeing_ghosts #Line 1 defines and names the method
    sam_tds = 0 
    sam_ints = 4 #Line 2 & 3 Define our variables relevant to the method. 
    puts sam_tds > sam_ints ? "Jets win!!" : (sam_ints >=4 ? "I'm seeing ghosts." : "Jets lose!!") 
#In Line 4 we define the behavior(s) we want our program to make when this method is called
end #And finally, we close the method with the 'end' keyword.

It's important to note we have to define our variables inside the method. Method's have there own level of Scope, which we will get deeper into in a later lesson. For now, just remember to define any variable you will need inside the method.

Now our method won't run automatically, we have to call it somewhere else in our program. So let's add a call for our method right underneath it:

def seeing_ghosts
    sam_tds = 0
    sam_ints = 4 
    puts sam_tds > sam_ints ? "Jets win!!" : (sam_ints >=4 ? "I'm seeing ghosts." : "Jets lose!!")
end

seeing_ghosts #=> I'm seeing ghosts.
#This is a call that will tell our program to run the 'seeing_ghosts' method

And we've successfully turned our code into a method!

Arguments

The above method is great and all, but it is written in a way that assumes Sam is the only one who sees ghosts! If we wanted to introduce ways to see if Dak Prescott or Big Ben see ghosts, we would have to write entirely different methods for each one. As a programmer, and especially a Rubyist, I'm too lazy for that - and so should you be! Enter arguments.

Arguments are a way to make our methods more dynamic and reusable. By adding in arguments and changing the hard-coded parts of our previous method, we can make it useful in a multitude of situations!

As an added bonus, arguments will also allow us to access variables outside of the method! For starters, let's see how our original seeing_ghosts method looks with arguments:

sam_tds = 0
sam_ints = 4

def seeing_ghosts(tds, ints) #The '()' after the method name denotes this method takes the arguments 'sam_tds' & 'sam_ints'. 
    puts sam_tds > sam_ints ? "Jets win!!" : (sam_ints >=4 ? "I'm seeing ghosts." : "Jets lose!!")
end

seeing_ghosts(sam_tds, sam_ints) #=> I'm seeing ghosts.

Just like that, we have a method with 1/3 less fat on it and we will be able to use those variables elsewhere in our code without redefining them as well!

But this method still discriminates against Sam, and I don't write code to only make Bills and Giants fans happy. So we will begin making this method a bit less Sam-specific (and use more conventional conditional logic):

def seeing_ghosts(tds, ints)
  if tds> ints
    puts "We win!!"
  elsif ints >=4 
    puts "I'm seeing ghosts."
  else
    puts "We lose!!"
  end
end

Note You can name your arguments anything, but try to keep a good sense of abstraction to make them easier to read. Here I decided tds & ints were specific enough so we could all understand what we are trying to do in the method.

This method will allow us the flexibility to enter either the number of tds/ints manually or place any defined variables from our code:

sam_tds = 0
sam_ints = 4

seeing_ghosts(sam_tds, sam_ints)
#=> I'm seeing ghosts.

Will work the same as:

seeing_ghosts(0, 4)
#=> I'm seeing ghosts.

Default Arguments

This method is pretty close to what we had in the last lesson, but we did have to cut out the team name to make it fit any QB. How can we call methods powerful if it just forces us to stupify our code and make it more generic?

The simple answer: it doesn't. We can add another argument called team, specify the team the QB plays for, and then use our old friend string interpolation! So let's do it!

def seeing_ghosts(tds, ints, team)
  if tds> ints
    puts "#{team} win!!"
  elsif ints >=4 
    puts "I'm seeing ghosts."
  else
    puts "#{team} lose!!"
  end
end

seeing_ghosts(7, 0, "Eagles")
#=> Eagles win!!

That's great and all, but as a Jets fan, I spend most of my time talking about and caring about the Jets. I don't want to type the team name every time if I don't have to. People should know I'm talking about the Jets by default, right?

Right!

You can set a default value that will automatically be passed if you choose not to specify a value for that argument! So lets set team to equal "Jets" by default!:

def seeing_ghosts(tds, ints, team = "Jets")
  if tds> ints
    puts "#{team} win!!"
  elsif ints >=4 
    puts "I'm seeing ghosts."
  else
    puts "#{team} lose!!"
  end
end

seeing_ghosts(2, 0)
#=> Jets win!!

There is no limit to the number of arguments you can assign a default value. We could add a name argument and set the default to = "He" for a generic QB quote like "#{name} is seeing ghosts." and a whole bunch more customizable options.

Methods Lab

When you're finished reviewing this lesson, head over to the Ruby Methods Lab, and complete all the tasks given. Have fun and good luck!

Common Ruby Operators and Conditional Logic

Brandon Weygant — Fri, 08 May 2020 18:38:43 +0000

This week I'm going to be covering common Ruby Operators (specifically the Comparison, common Boolean, and Ternary Operators) and an Introduction into Conditional Logic in Ruby as well.

Booleans in Ruby

Firstly, let us get an idea of what a boolean is in Ruby. A boolean in Ruby is simply something that refers to a value of true or false. Unlike some other programming languages, Boolean is not its own class in Ruby. Instead Ruby has the TrueClass and the FalseClass which for this lesson should be an adequate explanation. Read the supplementary material linked for more info.

The Common Ruby Operators

== aka The Comparison Operator: In the previous lesson we learned the = operator is used to declare a variable to a value. Ruby also boasts an operator == which is used to compare values and return true if both are equal.
Example:

1==1 #=> true

Whereas

 1==2 #=> false

"!" aka The "Single-Bang" Operator ! stands for "NOT". It's mainly used to manipulate something that is true into something that is false and vice versa.

puts 2 #=> true
puts !2 #=> false

"&&" aka The "AND" operator The && operator is used to tie 2 or more conditionals together. All values have to be true to be read as true.

true && true #=> true
true && false #=> false

"||" aka The "OR" Operator Like the && Operator the || Operator is also used to tie 2 or more conditionals together. The difference is only 1 of the conditionals has to be true to read as true.

true || true #=> true
true || false #=> true

"if", "elsif", and "else" in Ruby

if, elsif, and else all basically do the same thing: they tell the program to evaluate the proceeding conditional and if true to follow specific instructions. The most significant difference is where they are in an if\else statement. The following is the basic construct of an if\else statement in Ruby:

if condition_is_true
  instruction1
elsif condition_above_is_false_check_this_and_if_true
  instruction2
else
  instruction3
end

Notice else has no conditional? In most cases else is meant to capture all other circumstances not caught by the preceding conditions and you can ignore specifics and just put instructions.

Also, note elsif is spelled funny. This is a rare moment where I feel Ruby tried too hard to simplify things for devs, as this is just silly grammar.

Lastly, make sure to close out your conditionals with end.

And now, we can proceed to this week's example...

Sam Sees Ghosts

New York Jets Quarterback Sam Darnold is unfortunately judged far too harshly based on his "I'm seeing ghosts," game vs. New England. Outside of that 2 game stretch vs. NE and Jacksonville, he actually was really good!

But Sam did confess to seeing ghosts, and as such we as programmers have to acknowledge this truth in our code somehow. First, we can start by defining Sam's interceptions and touchdowns against NE.

sam_ints = 4
sam_tds = 0

It was a terrible game.

Next, we will put our first if statement:

if sam_tds > sam_ints
  puts "Jets win!!"
end

Obviously, this will output nothing in our console as sam_tds are less than sam_ints. So we need a condition that will output something when Sam has more INT's than TD's:

if sam_tds > sam_ints
  puts "Jets win!!"
else 
  puts "Jets lose!!"
end

# Will return "Jets lose!!" in the console.

Great, so we have a condition to display in our console, but just losing is not quite the same as seeing ghosts, is it? Let's modify our logic and add a third conditional in there so Sam will let us know when he's seeing ghosts.

if sam_tds > sam_ints
  puts "Jets win!!"
elsif sam_ints >= sam_tds
  puts "Jets lose!!"
else sam_ints >= 4
  puts "I'm seeing ghosts!"
end

# Will return "Jets lose!!" in the console.

Ok, what happened? Sam does have 4 or more int's so why wasn't that displayed? In Conditional Logic, the first conditional that processes as "true" will be the output. Since we cover all possible outcomes in our first two conditions, that is what will be read. For this reason, your more specific conditions should be higher up the logical ladder.

if sam_ints >= 4 
    puts "I'm seeing ghosts."
elsif sam_ints < sam_tds
    puts "Jets win!!"
else sam_ints >= sam_tds
    puts "Jets lose!!"
end

# Will return "I'm seeing ghosts." in the console.

With this, Sam can now see ghosts. However, what if Sam has 4 INT's, but 7 TD's? It's likely the Jets won that game, but Sam is still seeing ghosts. How do we help Sam bust these ghosts? We could just switch the if and elsif conditionals and instructions, and that's totally fine! Instead, we're going to use the "&&" to add an extra condition so our ghosts don't ruin Sam's gutsy performance.

sam_ints = 4
sam_tds = 7

if sam_ints >= 4 && sam_ints >= sam_tds
    puts "I'm seeing ghosts."
elsif sam_ints < sam_tds
    puts "Jets win!!"
else sam_ints >= sam_tds
    puts "Jets lose!!"
end

# Will return "Jets win!!" in the console.

This gives us a much better grip over the flow control of when Sam sees ghosts.

The Ternary Operator

A convenient little operator for some simple Conditional Logic, the Ternary operator allows us to assign one value if a condition is true and another if a condition is false.

We write the Ternary Operator in this pattern:

conditional ? action_if_true : action_if_false

So the statement

puts sam_ints >= sam_tds ? "I'm seeing ghosts." : "I'm not seeing ghosts."

Will produce the same result as the if/else statement:

if sam_ints >= sam_tds
   puts "I'm seeing ghosts."
else
   puts "I'm not seeing ghosts."
end

Nice! The Ternary Operator allowed us to write shorter, more condensed code. But we had 3 possible outcomes in our example. Can we write code using the Ternary Operator that captures more than 2 values?

Bonus Ternary Lesson!

It's possible to manipulate your code to use the Ternary Operator for more than 2 expressions. This isn't very advisable in a pro setting, as it can get messy quickly and very difficult for other programmers to read. BUT in a code challenge setting combining what might take 6 lines into 1 line can feel like a major win in itself!.

puts sam_tds > sam_ints ? "Jets win!!" : (sam_ints >=4 ? "I'm seeing ghosts." : "Jets lose!!")

And voila! With the code above we can do everything our completed if/else statement can do in 1 line.

Conditionals Lab

When you're finished reviewing this lesson, head over to the Ruby Conditionals Lab, and complete all the tasks given. Have fun and good luck!

Ruby Variables and String Interpolation

Brandon Weygant — Mon, 04 May 2020 15:01:44 +0000

So I decided to put together a series of class-style tutorials to teach my friends a little bit about Ruby. This is meant to be a series of tutorials, designed to be as basic of an introduction to Ruby as I can manage. Hope you all enjoy it.

Also, there's a better than 0% chance the student was high...

Variable Lab

When you're done watching the video and feel confident you can test your skills with the Ruby Tutorial - Variables Lab. Follow the instructions in README.md to clone the lab to your machine, and how to submit it when done. This guide assumes you have Ruby installed on your machine and a Github account already in place.

Job Hunting: Impressionable Company Rejections

Brandon Weygant — Wed, 22 Apr 2020 20:28:11 +0000

So if you've ever applied for a job, you've probably experienced quite a few rejections. Most of these rejections are not memorable in the least and quickly fade away. Others stick out and can actually shape the perception of your entire job hunt and whether it was a good or bad experience. So let's talk about a few (anonymous) rejections that stand out for me.

The Best Rejection

I got an interview through a mutual contact with a local company and the founder and lead developer were very eager to help me launch my career, but unfortunately my skill set didn't match up with what they were looking for at the time. After explaining this to me the founder still took the time to introduce me to the entire present staff and offered me an opportunity to work on my projects inside the company office (it has it's own coffee house!). Rejection and all, it was inspiring to meet a team willing to help put however they could.

The Worst Rejection

I had applied for a job at a startup whose business is getting developers like me jobs. They took the opportunity to reject me as an employee AND recruit me as a customer in the same letter. They explained my profile had been "flagged" as someone who could benefit from their program an proceeded with the sales pitch. Maybe they are right, but this wasn't the way to convince me.

Now, there is absolutely nothing wrong with being a customer at a prospective or even current employer. It's really dope if you are actually! But I had never heard of this service prior to researching them and applying. I went to them for work, and they turn it around and made it a sales opportunity? This was a massive turnoff for me towards the company.

Everything in Between

1. The "we had discussed it internally, but I didn't know they actually posted a job yet" Conversation

This one was a trip, though the guy was really nice. I was the first applicant so I got a call, and the guy told me this and that what I had applied for wasn't even going to be close to the job description. HE informed me he was in the "gathering applications phase" and would get back to me. Never did.

2. The "I've never heard of your school before" Conversation

I'm pretty sure the interviewer wanted to hear Flatiron School was an accredited college and not a coding boot camp. Is what it is.

3. The Overly Positive Reinforcement Even Though We've Never Talked Rejection

These for me are some of my favorite. It's one thing to praise people over the phone or in an interview when you're actually interacting with that person. But the emails after initial application implying how great a developer I am while telling me no? There is nice and there is trying too hard. The icing on the cake is these rarely come with any sort of feedback, only they are moving forward with someone else. At least the more neutral or negative ones let me know it's experience, quality, or tech stack even if they don't elaborate. Respect though.

4. Getting Ghosted After Initial Communication

It's one thing to be ignored off the rip after applying. It's another thing entirely to have a secondary non-interview interaction with the company and then get ghosted. Nothing like being asked to provide follow up information, providing asked for information, then never hearing back.

5. The "We Rejected You Already But One Week Later We Schedule an Interview for You Anyway Only For You To Fail A Technical Assessment...In A Language You Never Claimed You Knew" Rejection

That's the story. Got an opportunity through my coding bootcamp Flatiron School, got rejected, got another interview anyway. Writing was on the wall when I asked "What language was this" and butchered my assessment of a piece of code presented to me. No hard feelings, as this was an enjoyable experience.

Honorable Mention

**The Wait List - **Not technically a rejection, but, I've recently been wait-listed for the first time by a company I really would be excited to work for if the opportunity does arise. Getting wait-listed isn't inherently good or bad, there really are a number of good reasons why this could be, and there isn't any shame in being a companies 2nd (or even 12th) choice for an opportunity you want. Add in the impact of COVID-19 and there are even more reasons than ever why an employer may use a wait list.

That said, the wait list is probably the least satisfying answer you could receive, especially because you most likely went deep in the interview process with the company. There is at least closure with being rejected, even if it may hurt more initially.

Advice: In your initial bout with the total lack of closure you will likely experience, try to avoid asking "why?", to both yourself and the employer. There isn't really a satisfactory answer that will make you feel better and you will still be on the wait list at best. The employer has a right to there process, and while they likely wouldn't hold the inquiry against you, coming off as understanding and respectful of their process is less likely to get you knocked down (or off!) that wait list.

Conclusion

No rejection is entirely pleasant or satisfying, not even the office space offer I got before. Dealing with rejection, in all it's forms, is one of the key challenges in any job hunt. Think of it like this: Giving up because of how a company rejected you probably means the company was right not to hire you in the first place. Cold, but true.

These are just my experiences, and I am 100% certain they are very tame by comparison to some other stories. At the very least, I hope this means I have had some relatable experiences, if not exceptional. Thanks for reading and feel free to share your rejection stories below!

Working (and Playing!) with RPG Maker MV

Brandon Weygant — Wed, 15 Apr 2020 20:14:15 +0000

So self-isolation affects us all differently. One of the biggest issues for me has personally been work/life balance. I'm either spending too much time being "productive" (or worrying if I'm being productive enough) or too much time doing recreational activities (recently put in about 40 hours into Fallout 4 in under a week) and neither state is good to be in. Add in that over the last 1.5 years I've been neglecting my creative side to learn new skills and pursue new job opportunities, and you have a 3 headed beast of unfulfillment I had been struggling to satiate. Insert into my life RPG Maker MV!

What is RPG Maker MV

RPG Maker MV(RPGMMV) is a software for developing 16-bit 2-d games, think SNES style of RPG's like Chrono Trigger. Relative to many people's understanding of game development, RPGMMV does an excellent job streamlining the process and making it as simple as possible to make your own game. Map building is simple -even for the designed-ly challenged like myself-, character generation is very straight forward, and you can freely adjust your games database from items to battle mechanics to what the game will identify your stats as. It is a very thorough program even out of the box, with a couple of drawbacks.

The Limitations Out of The Box

Out of the box, it comes with a frustratingly limited amount of options and features, most noticeably when you try to build your first map. At first glance, the tilesets appear to be loaded with options, but you will quickly find they will never be able to fully realize your vision and are mostly for practice purposes. PandaMaru has some good free tilesets for you to work with, but if you are anything like me you'll be considering searching for an artist to fully customize your in-game artwork.
Event/NPC creation has a steep learning curve compared to the other basic features of the game. This is relative though as RPGMV is development software and not a game, and any new software is bound to have a learning curve.
Character creation is a breeze, and it feels easier than it should be because the standard character parts don't allow you to create many unique looking characters (for my tastes anyway). I guess while simple, it does come off as uninspiring.
Other miscellaneous annoyances for me were how they made door generation an event rather than part of a tileset, the base tilesets don't really complete any modern/sci-fi theme, and my in-game tutorial was unreadable.

For me, none of these issues were deal-breakers, although if you go into this trying to bring an idea to life these hurdles can be an inspiration killer. My recommendation is to take that great idea you have for a game and put it on the back burner until you complete some tutorials and can get some basic/slightly advanced functions down in a practice project.

What's Not In The Box

The most appealing feature about RPGMMV is that despite the limitations out of the box, there are tons of opportunities to customize your game under the hood however you see fit. This is primarily done with plugins, which the dev community has made sure there is no shortage of. The underlying code in RPGMMV is JavaScript, and as such all plugins are written in JS as well. Plugins come in all shapes and sizes, from complete core system overwrites like to more complementary plugins that may enhance a single particular feature. Unless you are determined to make a game with only the basic components and features (or much less likely you have a severe deficiency in imagination/creativity), plugins will be some of the first things you research to expand your realm of possibilities. Fortunately, the software is very accepting of this and welcomes third party additions with open arms. The plugin manager tool has a very visible and accessible shortcut right in the main taskbar on top.

Many plugins come with additional commands called note tags that can be used to access the game code and further customize specific features of the game. You place these note tags inside a box in the database called "Notes". For example, if you have Yanfly's "Level Up Growth Effects" plugin, you gain access to a nifty little note tag <Level Up stat Growth: +x>. If you put this note tag in the notes box of a particular class in the Database under "Classes" and replace stat with say ATK and x with 25, this will cause Attack to grow +25 per level up. There are hundreds of other note tags that are just as simple or way more complex, but each one allows you to customize your game as you see fit so you can stand out from the crowd even more.

Side Lesson: The Notes box was originally designed to take notes in. Somewhere in RPG Maker's existence, some clever people realized they could access and alter game code through this box! And the revolution started from then on!

Some of the plugins I've found most useful can be found at these links (not all are free):
Yanfly - Yanfly has a massive library of plugins, but all of their plugins are designed around Yanfly's Core Engine, so make sure to install that before the other plugins to prevent compatibility issues.
SumRndmDde - In addition to these awesome plugins, this guy also has a great tutorial series her to get you up and running quickly.

Conclusion

RPG Maker MV has been an awesome work/life balancer for me. It has been incredibly fun learning to develop games on this platform, and it has just the right amount of tools available to help maintain and sharpen my existing skills in JS. It's a bit of a steep price when not on sale ($79.99 on Steam), but if you are at least semi-serious about game development as a hobby (or more) then it is worth the price as you will likely put more hours into this than a standard game and not even realize it.

Some Job Hunting Resources and Advice

Brandon Weygant — Thu, 09 Apr 2020 18:50:03 +0000

General Advice and Observations

Non-essential Skilled Job Posts Have All Upgraded Reqs
This may just be me or software/web development specifically, but I have noticed that many Junior/Entry level roles have gone away. Everything right now seems to be upgraded one level up. Senior roles are everywhere, and it is really hard to find a role that matches someone with less than 5 years of experience right now. This may be in part because a lot of jobs suddenly shifted to remote, and employers have always valued more experience in those roles. All I can say is keep applying anyway.

Networking From Home

Probably the biggest shift in job-hunting is how networking has been effected. Now is a good time to connect and reinforce existing network contacts - even engaging non-professionally just to check-in. With meetups, conventions, and other group events on pause for a while, it gets very hard to expand your network by physically meeting new people.

If anyone knows of any Virtual Job Fairs or Online Networking Sessions/Events (not LinkedIn or other social media) please let me know by commenting down below.

Volunteer Opportunities

There actually are some pretty unique volunteer opportunities to help gain some experience. For example New York is putting together a Covid-19 SWAT Team and the White House Office of Science and Technology Policy has made a mass call out for tech experts to create a machine readable Covid-19 dataset. There is literally zero harm in checking out volunteer opportunities, and may actually be the best way to network in this crisis.

Resources

1. Candor
Anybody who hasn't seen this crowd-sourced list yet should really check it out. Easily the most helpful resource available. It tells you whether a company is hiring, in a hiring freeze, or laying off. It also tracks industry-specific statistics regarding how many companies in a said field are in a specified status.

2. Remote Jobs in March Google Doc
This is a massive list of remote jobs that were posted and available in the month of March (approximately 1589 jobs or so). I haven't been able to validate how many of these positions were frozen, changed, or removed as of today, but it is a resource worth checking out. The list is organized by company, contains a link to the job postings, and has several labels provided to each job for easy doc navigation.

3. Power to Fly
My favorite traditional blog article so far, this is a list of 28 well-known companies still hiring. Link's to each companies postings on www.powertofly.com where you can get more detailed info on each position.

4. Hacker News
A web sourced forum article that is worth taking a look at.

Conclusion

Just stay safe, be careful, and keep pressing forward.