The basic premise is the host, Monty Hall, presents 3 closed doors to a contestant, one of which hides a new car, and the other 2 doors contain goats. The goal for the contestant is to choose the door hiding the new car.

To start the game, the contestant chooses 1 of the 3 doors. But before they can see what's inside, the host opens one of the remaining doors where this is a goat. The host then offers the contenstant the option to switch their door selection to the other remaining door or to stick with their first choice.

The brain teaser: Is it better for the contestant to stay, switch, or does it not matter?

To find out, I wrote a Ruby script, and added in a bit of Lord of the Rings by changing goats to orcs and setting the prize as farthings.

Ruby script with Lord of the Rings theme

def green_dragon

  stay_wins = 0
  switch_wins = 0
  show_door = nil
  switch_door = nil

  tries = 10000

  tries.times do
    initial_guess = rand(3)
    door_items = ["500 farthings", "1 orc", "1 orc"].shuffle!
    door_items.each_with_index do |item, door_index|
      if door_index != initial_guess and item != "500 farthings"
        show_door = door_index
      end
    end
    
    switch_door = ((0..2).to_a - [initial_guess, show_door])[0]

    if door_items[initial_guess] == "500 farthings"
      stay_wins += 1
    end

    if door_items[switch_door] == "500 farthings"   
      switch_wins += 1
    end

  end

  stay_wins = (stay_wins.to_f / tries.to_f) * 100
  switch_wins = (switch_wins.to_f / tries.to_f) * 100
  results = {"Stay Wins" => stay_wins, "Switch Wins" => switch_wins}
 
end

Code breakdown

def green_dragon

I define a method and give it a name - in this case green_dragon

stay_wins = 0 and switch_wins = 0

To get a count of wins won by staying and a count of wins won by switching, I add the two variables stay_wins and switch_wins, and set their starting count to 0.

show_door = nil
switch_door = nil

show_door

Represents one of the doors containing an orc that the hosts shows the contestant after their initial selection.

switch_door

Represents the door the hosts offers the contestant to switch to instead of staying with their initial door selection.

= nil

While each door will hold a single index value (0,1,2) during each iteration, they have no value at the start, and begin with nil as their initial value.

tries = 10000

This variable represents the number of times the do / end statement will run. 10000 will give us a good enough sample to draw a conclusion, but can be any integer (50000, 1230000).

tries.times

times is a public ruby method for iterating over a block a certain number of times - in this case, 1000 times as defined by the tries variable.

initial_guess = rand(3)

initial_guess is the guest's first door selection. rand sets the index value within initial_guess to random through each iteration of the loop. (3) gives us three index values for the three doors (0, 1, 2)

door_items = ["500 farthings, "1 orc", "1 orc"].shuffle!

The door_items array ["500 farthings", "1 orc", "1 orc"] gives us the items behind the doors.

shuffle is a method that shuffles items in an array through each iteration.

! (often referred to as bang) modifies the object it's called on. It is ruby convention to use ! at the end of a method when something will be modified in your code.

door_items.each_with_index do |item, door_index|

This will iterate through each index of the door items.

The variables in the pipe |item, door_index| are placeholders. item represents the item string (such as "1 orc"), and door_index represents the index number of the item (0, 1, or 2). Naming it door_index makes it clear the value corresponds to a door position.

 if door_index != initial_guess and item != "500 farthings"
  show_door = door_index
 end

This is an if conditional statement. It states if the index does not equal the initial_guess and if the item does not equal the desired prize ("farthings"), then that index belongs to the show_door. The 1st end ends the conditional statement, and the second end ends the each do loop.

switch_door = ((0..2).to_a - [initial_guess, show_door])[0]

This statement finds the switch_door. (0..2).to_a takes the potential index value of the three doors (0,1,2) and puts them in an array [0,1,2]. - [intial_guess, show_door] subtracts the indices belonging to initial_guess and show_door, leaving you with the index value of the switch_door in an array. Now we need the index value out of array form, and that's where [0] comes in. This grabs the value of the 0 index position of an array.

 if door_items[initial_guess] == "500 farthings"
   stay_wins += 1
 end
 if door_items[switch_door] == "500 farthings"   
   switch_wins += 1
 end

The first conditional statement finds out if the initial_guess item is farthings, and if so add 1 win to stay_wins. The second conditional find out if the switch_door contains the farthings and if so add 1 win to switch_wins. The 1st two ends conclude the conditional statements, and the last end take us out of the loop.

  stay_wins = (stay_wins.to_f / tries.to_f) * 100
  switch_wins = (switch_wins.to_f / tries.to_f) * 100
  results = {"Stay Wins" => stay_wins, "Switch Wins" => switch_wins}

stay_wins and switch_wins now contain how many times a contestant sticking with their initial selection won over how many times they played, then converts the answer to a percentage.

To calculate the variables, they need to be in float form .to_f

results = {"Stay Wins" => stay_wins, "Switch Wins" => switch_wins}

We need to put stay_wins and switch_wins into a hash, otherwise the value of the variables will come up as nil. A hash is an associative array of key, value pairs. While an array has default index integer values (0,1,2,3...) to reference an item within the array, hashes allow you to use any object type.

For example if I wrote this hash: animals = {"monkeys" => "primates", "sharks" => "fish"}. I could type: puts animals["monkeys"] and I would get the string "primates" as the result.

The conclusion

It is best for the contestant to choose switch over stay. Consistently the results showed choosing to stay meant 1/3 odds you will win, while switching gives you 2/3 odds.

Run in the directory you'd like to zip:

zip -r zip.zip ./ -x *.git* -x *.zip*

Zip is a command line utility and you can find the man page here.

You can also view the man page in your terminal with the command:

man zip

One solution for this is to use browser developer tools and a little javascript.

Javascript example

As a quick example, let's say you'd like to only see a numbered text list of what connectors available for Airbyte.

You can open your browser's developer tools and run the following javascript in the console.

Note: If you're unsure how to use your browser's developer tools, you may find Mozilla's article here helpful to review.

// Get all the elements containing the names of the integrations and stores them in a variable.
let title = document.documentElement.getElementsByClassName('card-title');

// Create an empty array called 'titlesArray' to store the text of each 'card-title' element
var titlesArray = [];

// Loop through each 'card-title' element
for (const element of title) {
  // Add the text of the current 'card-title' element to the 'titlesArray' array
  titlesArray.push(element.innerText)
}

// Sort the 'titlesArray' array alphabetically
let titlesArraySort = titlesArray.sort();

// Create a new ordered list element using the createElement method of the Document Object Model (DOM)
let list = document.createElement('ol');

// Loop through each element in the 'titlesArraySort' array
for (let i=0; i<titlesArraySort.length; i++){ 
  // Create a new list item element using the createElement method of the DOM
  let item = document.createElement('li'); 
  // Set the text of the list item to the current element in the 'titlesArraySort' array
  item.innerText = titlesArraySort[i]; 
  // Append the new list item to the ordered list element created earlier
  list.appendChild(item); 
} 

// Define a function called 'removeAllChildNodes' that will remove all child nodes from a given parent element
function removeAllChildNodes(parent) { 
  while (parent.firstChild) { 
    parent.removeChild(parent.firstChild); 
  } 
} 

// Get a reference to the <body> element using the querySelector method of the DOM
let bodyElement = document.querySelector('body'); 

// Remove all child nodes from the <body> element using the removeAllChildNodes function
removeAllChildNodes(bodyElement);

// Append the new ordered list element to the <body> element using the appendChild method of the DOM
bodyElement.appendChild(list);

// Add margin and padding for better readability

listElement.style.marginLeft = "50px"
list.style.padding = "50px"

Images of the webpage before & after javascript

Before

After

To push changes from a local file to a remote server, use scp in the local terminal:

$scp index.html username@ip-address:/var/www/desired-directory

To push changes from the entire local directory use scp -r ./ in the local terminal:

scp -r ./ username@ip-address:/var/www/desired-directory

1. Create a new user and give them administrator privileges.
2. Logout of WordPress and log back in with the new user’s credentials.
3. Delete the old administrator
4. If the old administrator created any posts, WordPress will prompt you to either attribute the posts to the new user or delete the posts entirely. If there are no posts associated with the user, WordPress will ask you to confirm deletion.
5. Now you have the admin username you want.

Example

$ git commit

Git commit is like save in a word document. It is a super helpful command that records what you’ve done to the repository, and it’s best practice to do it often.

But you have to type git commit over and over again and what if you want to save a little time. Here is where aliases comes in handy. As a basic example, you can type “git ct” as opposed to “git commit” and have it function the same way.

$ git config --global alias.ct 'commit -v'

Alternatively you can also achieve the same thing by adding this to your git config file:

[alias]
       ct = commit

You can also choose to have a little fun with git alias rather than focus on efficiency.

For example, if you want to Harry Potterify git status you can do:

$ git config --global alias.accio 'status -v'

Or if you think monkeys are the greatest, to which, I agree, you can do:

git config --global alias.monkeysrock 'status -v'

To understand how foreign keys are used in Rails, we need to know a little about models, databases, and migrations too. To better illustrate the use of foreign keys and these other concepts, we’ll board the USS Enterprise.

USS Enterprise example

You are an ensign within the engineering department of the USS Enterprise. You have a list of tasks displayed on your PADD (personal access display device) that you need to complete.

Your first task today is to complete maintenance of the warp drive, and it was ordered by Chief Engineer Geordi La Forge. When Geordi first added this task it saves to a database (like an excel spreadsheet). Your PADD retrieves information from that database in order to display the tasks Geordi added.

The database is organized into tables, which is like having an excel spreadsheet broken up into categories. For example, the list of tasks you need to complete are in the tasks table. This organization is key to speedy data access, because rather than the computer searching through mountains of data (medical records, officer profiles, mission notes, etc, etc) to find one item (a task) it can just look through the tasks table.

But with this separation, the tables need a way to tap into each other in some instances. For example, the task maintenance of warp drive in the tasks table needs to be associated with an officer(you the ensign) in the officers table.

In one file here’s how you associate the officers table with the tasks table:

class Officer < ActiveRecord::Base
    has_many :tasks
end

And in another file here’s how you can associate tasks with the officers table:

class Task < ActiveRecord::Base
    belongs_to :officers
end

Breaking it Down:

class Officer < ActiveRecord::Base
class Task < ActiveRecord::Base

These lines of code create what is called a model class in Ruby. In this example, we are creating the Officer model to chat with the officers table and the Task model to chat with the tasks table.

Models are like the guardians of the database. They tell their data what it’s allowed to do, decides which data is valid for their table, who their data can chat with and in what way, and how the data can be manipulated.

has_many :tasks
belongs_to :officers

These lines of code describe the association(relationship) between the two tables. It states a single officer can have many tasks, and a task belongs to a single officer.

Now that the Officer model and the Task model are associated with each other, we need attributes. An attribute describes the type of data we are entering into the table. For example, for the Officer table we need the attributes id, officer’s name, and their rank. For the Task table we need id, officer’s id, and task. The id is a way for Rails to locate the data needed, and is automatically generated when you create the model.

Luckily, with Ruby on Rails when you create a model (like the Officer and Task models) you automatically create migration files containing the attributes. Migrations are a less time-consuming and easier way to alter your database schema (structure of the database) than having to write SQL(database language) by hand.

This is how to create the Officer and Task models mentioned above within the terminal:

rails generate model Officer name:text rank:text
rails generate model Task task:text officer_id:integer

And here is the code that’s generated in the task and officer migration files:

class CreateTasks < ActiveRecord::Migration
  def change
    create_table :tasks do |t|
      t.integer :id
      t.integer :officer_id
      t.text :task    
    end
  end
end

class CreateTasks < ActiveRecord::Migration
  def change
    create_table :tasks do |t|
      t.integer :id
      t.integer :officer_id
      t.text :task    
    end
  end
end