Sockets - Erica & Karla G.

[kguadron]

Adagrams

Congratulations! You're submitting your assignment.

Comprehension Questions

Feature	Feedback
What are the components that make up a method?	A method is made up of the method signature and the method block.
What are the advantages of using git when collaboratively working on one code base?	The advantage is that it's easy to see what other collaborators are doing and share/merge changes.
What kind of relationship did you and your pair have with the unit tests?	It was helpful for debugging and seeing where in the code the errors were coming up.
Does your code use any methods from the Enumerable mixin? If so, where and why was it helpful?	We used .each and .each_char. It was helpful in iterating through the individual elements in the different arrays.
What was one method you and your pair used to debug code?	We used the unit tests and puts statements.
What are two discussion points that you and your pair discussed when giving/receiving feedback from each other that you would be willing to share?	1) We have different coding paces and acknowledged that it's important to strike a balance. 2) We fostered a safe/comfortable working dynamic where we were able to communicate needs, ideas, and points of confusion.

[droberts-sea]

Adagrams

What We're Looking For

Feature	Feedback
General
Answered comprehension questions	yes
Small commits with meaningful commit messages	yes - good work!
Code Requirements
draw_letters method
Uses appropriate data structure to store the letter distribution	see inline
All tests for draw_letters pass	yes
uses_available_letters? method
All tests for uses_available_letters? pass	yes
score_word method
Uses appropriate data structure to store the letter scores	see inline
All tests for score_word pass	yes
highest_score_from method
Appropriately handles edge cases for tie-breaking logic	yes
All tests for highest_score_from pass	yes
Overall

Good job overall. There are a few places where things could be cleaned up, which I've tried to call out below, but in general I am happy with what I see here. It's clear to me that the learning goals around working with methods and tests were met. Keep up the hard work!

[droberts-sea]

I love this data structure - it makes it very clear how many there are of each letter. Could you store it in a constant?

[droberts-sea]

By this logic, you're as likely to draw an e as you are a z!

Instead, you might create an array containing all the letters, with code similar to this:

letter_counts = {
  # the hash you had before
}
letters = []
letter_counts.each do |letter, count|
  count.times do
    letters << letter
  end
end

Then you could pull a random tile with letters.sample and get a nice even distribution.

[droberts-sea]

Be careful about this sort of monkey patching - it's typically considered bad form. Instead, you could write a helper method that's not part of the Array class:

def delete_from(hay, needles)
  needles.each do |needle|
    if index = hay.index(needle)
      hay.delete_at(index)
    end
  end
end

[droberts-sea]

Since you only use delete_elements_in_ with an array of length 1, it might make sense to make the argument be a single object instead of an array.

Please make sure you fully understand the code you borrow from other sources before including it in your project.

[droberts-sea]

While this case statement works, it means that the information about which letter has which score is locked into this piece of code, and can't easily be used elsewhere. For example, if you wanted to display the value of each letter in a hand, you would need to repeat this work.

An alternative approach would be to store the letter scores in a hash, something like this:

LETTER_SCORES = {
  "A" => 1
  "B" => 3,
  "C" => 3,
  "D" => 2,
  # ...
}

Then to get the score for a letter, you can say LETTER_SCORES[letter].