Merge 295fe153ad into 7f1c243310

Hello, I've added a small blockquote below the description to indicate that this method of accessing an indefinite number of function arguments has been superseded by the use of the spread operator via rest parameters for ES6+ compatibility.

README.md

@@ -10,7 +10,7 @@ pairing with smart people at Hashrocket.
 
 For a steady stream of TILs, [sign up for my newsletter](https://crafty-builder-6996.ck.page/e169c61186).
 
-_1514 TILs and counting..._
+_1515 TILs and counting..._
 
 ---
 
@@ -1225,6 +1225,7 @@ _1514 TILs and counting..._
 - [Finding The Source of Ruby Methods](ruby/finding-the-source-of-ruby-methods.md)
 - [Format A Hash Into A String Template](ruby/format-a-hash-into-a-string-template.md)
 - [Forward All Arguments To Another Method](ruby/forward-all-arguments-to-another-method.md)
+- [Gather Positional Arguments In Method Definition](ruby/gather-positional-arguments-in-method-definition.md)
 - [Generate A Signed JWT Token](ruby/generate-a-signed-jwt-token.md)
 - [Generate Ruby Version And Gemset Files With RVM](ruby/generate-ruby-version-and-gemset-files-with-rvm.md)
 - [Get Info About Your RubyGems Environment](ruby/get-info-about-your-ruby-gems-environment.md)

javascript/accessing-arguments-to-a-function.md

@@ -5,6 +5,8 @@ an array-like object with all of the arguments to the function. Even if not
 all of the arguments are referenced in the function signature, they can
 still be accessed via the `arguments` object.
 
+> For ES6+ compatibility, the `spread` operator used via [rest parameters](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters) is preferred over the `arugments` object when accessing an abritrary number of function arguments.
+
 ```javascript
 function argTest(one) {
   console.log(one);

ruby/gather-positional-arguments-in-method-definition.md

@@ -0,0 +1,55 @@
+# Gather Positional Arguments In Method Definition
+
+The `*` symbol can be used in Ruby in a method definition to gather up an
+arbitrary number of positional arguments.
+
+For instance, we can gather all positional arguments with this method
+definition:
+
+```ruby
+def gather_all(*args)
+  puts args
+end
+```
+
+Or we can isolate the first positional arg and then gather the rest:
+
+```ruby
+def first_and_rest(first, *rest)
+  puts "First: #{first}, Rest: #{rest}"
+end
+```
+
+We can even do something a bit more interesting like isolating the first and
+last arguments while gathering up everything else in the middle:
+
+```ruby
+def pop_parens(left, *middle, right)
+  if left != '(' || right != ')'
+    raise "Uh oh!"
+  else
+    if middle.size == 1
+      puts "Found: #{middle.first}"
+    else
+      pop_parens(*middle)
+    end
+  end
+end
+```
+
+Here is what it looks like if we splat some different sets of arguments into
+that method call:
+
+```ruby
+> tokens1 = "((((4))))".split('')
+=> ["(", "(", "(", "(", "4", ")", ")", ")", ")"]
+> tokens2 = "((4))))".split('')
+=> ["(", "(", "4", ")", ")", ")", ")"]
+> pop_parens(*tokens1)
+Found: 4
+=> nil
+> pop_parens(*tokens2)
+(irb):87:in `pop_parens': Uh oh! (RuntimeError)
+```
+
+[source](https://ruby-doc.org/3.3.6/syntax/methods_rdoc.html#label-Array-2FHash+Argument)