concurrent-ruby 0.4.1 → 0.5.0.pre.1

data/md/agent.md

@@ -1,142 +0,0 @@
-# Secret Agent Man
-
-`Agent`s are inspired by [Clojure's](http://clojure.org/) [agent](http://clojure.org/agents) function.
-An `Agent` is a single atomic value that represents an identity. The current value
-of the `Agent` can be requested at any time (`deref`). Each `Agent` has a work queue and operates on
-the global thread pool (see below). Consumers can `post` code blocks to the
-`Agent`. The code block (function) will receive the current value of the `Agent` as its sole
-parameter. The return value of the block will become the new value of the `Agent`. `Agent`s support
-two error handling modes: fail and continue. A good example of an `Agent` is a shared incrementing
-counter, such as the score in a video game.
-
-An `Agent` must be initialize with an initial value. This value is always accessible via the `value`
-(or `deref`) methods. Code blocks sent to the `Agent` will be processed in the order received. As
-each block is processed the current value is updated with the result from the block. This update
-is an atomic operation so a `deref` will never block and will always return the current value.
-
-When an `Agent` is created it may be given an optional `validate` block and zero or more `rescue`
-blocks. When a new value is calculated the value will be checked against the validator, if present.
-If the validator returns `true` the new value will be accepted. If it returns `false` it will be
-rejected. If a block raises an exception during execution the list of `rescue` blocks will be
-seacrhed in order until one matching the current exception is found. That `rescue` block will
-then be called an passed the exception object. If no matching `rescue` block is found, or none
-were configured, then the exception will be suppressed.
-
-`Agent`s also implement Ruby's [Observable](http://ruby-doc.org/stdlib-2.0/libdoc/observer/rdoc/Observable.html).
-Code that observes an `Agent` will receive a callback with the new value any time the value
-is changed.
-
-## Copy Options
-
-Object references in Ruby are mutable. This can lead to serious problems when
-the value of an `Agent` is a mutable reference. Which is always the case unless
-the value is a `Fixnum`, `Symbol`, or similar "primative" data type. Each
-`Agent` instance can be configured with a few options that can help protect the
-program from potentially dangerous operations. Each of these options can be
-optionally set when the `Agent` is created:
-
-* `:dup_on_deref` when true the `Agent` will call the `#dup` method on the
-  `value` object every time the `#value` methid is called (default: false)
-* `:freeze_on_deref` when true the `Agent` will call the `#freeze` method on the
-  `value` object every time the `#value` method is called (default: false)
-* `:copy_on_deref` when given a `Proc` object the `Proc` will be run every time
-  the `#value` method is called. The `Proc` will be given the current `value` as
-  its only parameter and the result returned by the block will be the return
-  value of the `#value` call. When `nil` this option will be ignored (default:
-  nil)
-
-## Examples
-
-A simple example:
-
-```ruby
-require 'concurrent'
-
-score = Concurrent::Agent.new(10)
-score.value #=> 10
-
-score << proc{|current| current + 100 }
-sleep(0.1)
-score.value #=> 110
-
-score << proc{|current| current * 2 }
-sleep(0.1)
-score.value #=> 220
-
-score << proc{|current| current - 50 }
-sleep(0.1)
-score.value #=> 170
-```
-
-With validation and error handling:
-
-```ruby
-score = Concurrent::Agent.new(0).validate{|value| value <= 1024 }.
-          rescue(NoMethodError){|ex| puts "Bam!" }.
-          rescue(ArgumentError){|ex| puts "Pow!" }.
-          rescue{|ex| puts "Boom!" }
-score.value #=> 0
-
-score << proc{|current| current + 2048 }
-sleep(0.1)
-score.value #=> 0
-
-score << proc{|current| raise ArgumentError }
-sleep(0.1)
-#=> puts "Pow!"
-score.value #=> 0
-
-score << proc{|current| current + 100 }
-sleep(0.1)
-score.value #=> 100
-```
-
-With observation:
-
-```ruby
-bingo = Class.new{
-  def update(time, score)
-    puts "Bingo! [score: #{score}, time: #{time}]" if score >= 100
-  end
-}.new
-
-score = Concurrent::Agent.new(0)
-score.add_observer(bingo)
-
-score << proc{|current| sleep(0.1); current += 30 }
-score << proc{|current| sleep(0.1); current += 30 }
-score << proc{|current| sleep(0.1); current += 30 }
-score << proc{|current| sleep(0.1); current += 30 }
-
-sleep(1)
-#=> Bingo! [score: 120, time: 2013-07-22 21:26:08 -0400]
-```
-
-## Copyright
-
-*Concurrent Ruby* is Copyright &copy; 2013 [Jerry D'Antonio](https://twitter.com/jerrydantonio).
-It is free software and may be redistributed under the terms specified in the LICENSE file.
-
-## License
-
-Released under the MIT license.
-
-http://www.opensource.org/licenses/mit-license.php  
-
-> Permission is hereby granted, free of charge, to any person obtaining a copy  
-> of this software and associated documentation files (the "Software"), to deal  
-> in the Software without restriction, including without limitation the rights  
-> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell  
-> copies of the Software, and to permit persons to whom the Software is  
-> furnished to do so, subject to the following conditions:  
-> 
-> The above copyright notice and this permission notice shall be included in  
-> all copies or substantial portions of the Software.  
-> 
-> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR  
-> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,  
-> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE  
-> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER  
-> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  
-> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN  
-> THE SOFTWARE.  

data/md/channel.md

@@ -1,40 +0,0 @@
-# Change the dang channel!
-
-`Channel` is a functional programming variation of `Actor`, based very loosely on the
-[MailboxProcessor](http://blogs.msdn.com/b/dsyme/archive/2010/02/15/async-and-parallel-design-patterns-in-f-part-3-agents.aspx)
-agent in [F#](http://msdn.microsoft.com/en-us/library/ee370357.aspx).
-The `Actor` is used to create objects that receive messages from other
-threads then processes those messages based on the behavior of the class. `Channel`
-creates objects that receive messages and processe them using the block given
-at construction. `Channel` is implemented as a subclass of
-[Actor](https://github.com/jdantonio/concurrent-ruby/blob/master/md/actor.md)
-and supports all message-passing methods of that class. `Channel` also supports pools 
-with a shared mailbox.
-
-See the [Actor](https://github.com/jdantonio/concurrent-ruby/blob/master/md/actor.md)
-documentation for more detail.
-
-## Usage
-
-```ruby
-require 'concurrent'
-
-channel = Concurrent::Channel.new do |msg|
-  sleep(1)
-  puts "#{msg}\n"
-end
-
-channel.run! => #<Thread:0x007fa123d95fc8 sleep>
-
-channel.post("Hello, World!") => 1
-# wait...
-=> Hello, World!
-
-future = channel.post? "Don't Panic." => #<Concurrent::Contract:0x007fa123d6d9d8 @state=:pending...
-future.pending? => true
-# wait...
-=> "Don't Panic."
-future.fulfilled? => true
-
-channel.stop => true
-```

data/md/dereferenceable.md

@@ -1,49 +0,0 @@
-# Dereferenceable
-
-Object references in Ruby are mutable. This can lead to serious problems when
-the `#value` of a concurrent object is a mutable reference. Which is always the
-case unless the value is a `Fixnum`, `Symbol`, or similar "primitive" data type.
-Most classes in this library that expose a `#value` getter method do so using
-the `Dereferenceable` mixin module.
-
-Objects with this mixin can be configured with a few options that can help protect
-the program from potentially dangerous operations.
-
-* `:dup_on_deref` when true  will call the `#dup` method on the
-  `value` object every time the `#value` method is called (default: false)
-* `:freeze_on_deref` when true  will call the `#freeze` method on the
-  `value` object every time the `#value` method is called (default: false)
-* `:copy_on_deref` when given a `Proc` object the `Proc` will be run every time
-  the `#value` method is called. The `Proc` will be given the current `value` as
-  its only parameter and the result returned by the block will be the return
-  value of the `#value` call. When `nil` this option will be ignored (default:
-  nil)
-
-## Copyright
-
-*Concurrent Ruby* is Copyright © 2013 [Jerry D'Antonio](https://twitter.com/jerrydantonio).
-It is free software and may be redistributed under the terms specified in the LICENSE file.
-
-## License
-
-Released under the MIT license.
-
-http://www.opensource.org/licenses/mit-license.php  
-
-> Permission is hereby granted, free of charge, to any person obtaining a copy  
-> of this software and associated documentation files (the "Software"), to deal  
-> in the Software without restriction, including without limitation the rights  
-> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell  
-> copies of the Software, and to permit persons to whom the Software is  
-> furnished to do so, subject to the following conditions:  
-> 
-> The above copyright notice and this permission notice shall be included in  
-> all copies or substantial portions of the Software.  
-> 
-> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR  
-> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,  
-> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE  
-> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER  
-> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  
-> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN  
-> THE SOFTWARE.  

data/md/future.md

@@ -1,125 +0,0 @@
-# We're Sending You Back to the Future!
-
-`Future`s are inspired by [Clojure's](http://clojure.org/) [future](http://clojuredocs.org/clojure_core/clojure.core/future)
-function. A future represents a promise to complete an action at some time in the future.
-The action is atomic and permanent. The idea behind a future is to send an operation for
-asynchronous completion, do other stuff, then return and retrieve the result of the async
-operation at a later time. `Future`s run on the global thread pool (see below).
-
-`Future`s have three possible states: *pending*, *rejected*, and *fulfilled*. When a `Future` is created it is set
-to *pending* and will remain in that state until processing is complete. A completed `Future` is either *rejected*,
-indicating that an exception was thrown during processing, or *fulfilled*, indicating succedd. If a `Future` is
-*fulfilled* its `value` will be updated to reflect the result of the operation. If *rejected* the `reason` will
-be updated with a reference to the thrown exception. The predicate methods `pending?`, `rejected`, and `fulfilled?`
-can be called at any time to obtain the state of the `Future`, as can the `state` method, which returns a symbol.
-
-Retrieving the value of a `Future` is done through the `value` (alias: `deref`) method. Obtaining the value of
-a `Future` is a potentially blocking operation. When a `Future` is *rejected* a call to `value` will return `nil`
-immediately. When a `Future` is *fulfilled* a call to `value` will immediately return the current value.
-When a `Future` is *pending* a call to `value` will block until the `Future` is either *rejected* or *fulfilled*.
-A *timeout* value can be passed to `value` to limit how long the call will block. If `nil` the call will
-block indefinitely. If `0` the call will not block. Any other integer or float value will indicate the
-maximum number of seconds to block.
-
-The `Future` class also includes the Ruby standard library
-[Observable](http://ruby-doc.org/stdlib-2.0/libdoc/observer/rdoc/Observable.html) module. On fulfillment
-or rejection all observers will be notified according to the normal `Observable` behavior. The observer
-callback function will be called with three parameters: the `Time` of fulfillment/rejection, the
-final `value`, and the final `reason`. Observers added after fulfillment/rejection will still be
-notified as normal. The notification will occur on the global thread pool.
-
-## Examples
-
-A fulfilled example:
-
-```ruby
-require 'concurrent'
-
-count = Concurrent::Future.new{ sleep(10); 10 }
-count.state #=> :pending
-count.pending? #=> true
-
-# do stuff...
-
-count.value(0) #=> nil (does not block)
-
-count.value #=> 10 (after blocking)
-count.state #=> :fulfilled
-count.fulfilled? #=> true
-count.value #=> 10
-```
-
-A rejected example:
-
-```ruby
-count = Concurrent::Future.new{ sleep(10); raise StandardError.new("Boom!") }
-count.state #=> :pending
-count.pending? #=> true
-
-deref(count) #=> nil (after blocking)
-count.rejected? #=> true
-count.reason #=> #<StandardError: Boom!> 
-```
-
-An example with observation:
-
-```ruby
-class Ticker
-  Stock = Struct.new(:symbol, :name, :exchange)
-
-  def update(time, value, reason)
-    ticker = value.collect do |symbol|
-      Stock.new(symbol['symbol'], symbol['name'], symbol['exch'])
-    end
-
-    output = ticker.join("\n")
-    print "#{output}\n"
-  end
-end
-
-yahoo = Finance.new('YAHOO')
-future = Concurrent::Future.new { yahoo.update.suggested_symbols }
-future.add_observer(Ticker.new)
-
-# do important stuff...
-
-#>> #<struct Ticker::Stock symbol="YHOO", name="Yahoo! Inc.", exchange="NMS">
-#>> #<struct Ticker::Stock symbol="YHO.DE", name="Yahoo! Inc.", exchange="GER">
-#>> #<struct Ticker::Stock symbol="YAHOY", name="Yahoo Japan Corporation", exchange="PNK">
-#>> #<struct Ticker::Stock symbol="YAHOF", name="YAHOO JAPAN CORP", exchange="PNK">
-#>> #<struct Ticker::Stock symbol="YOJ.SG", name="YAHOO JAPAN", exchange="STU">
-#>> #<struct Ticker::Stock symbol="YHO.SG", name="YAHOO", exchange="STU">
-#>> #<struct Ticker::Stock symbol="YHOO.BA", name="Yahoo! Inc.", exchange="BUE">
-#>> #<struct Ticker::Stock symbol="YHO.DU", name="YAHOO", exchange="DUS">
-#>> #<struct Ticker::Stock symbol="YHO.HM", name="YAHOO", exchange="HAM">
-#>> #<struct Ticker::Stock symbol="YHO.BE", name="YAHOO", exchange="BER">
-```
-
-## Copyright
-
-*Concurrent Ruby* is Copyright &copy; 2013 [Jerry D'Antonio](https://twitter.com/jerrydantonio).
-It is free software and may be redistributed under the terms specified in the LICENSE file.
-
-## License
-
-Released under the MIT license.
-
-http://www.opensource.org/licenses/mit-license.php  
-
-> Permission is hereby granted, free of charge, to any person obtaining a copy  
-> of this software and associated documentation files (the "Software"), to deal  
-> in the Software without restriction, including without limitation the rights  
-> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell  
-> copies of the Software, and to permit persons to whom the Software is  
-> furnished to do so, subject to the following conditions:  
-> 
-> The above copyright notice and this permission notice shall be included in  
-> all copies or substantial portions of the Software.  
-> 
-> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR  
-> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,  
-> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE  
-> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER  
-> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  
-> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN  
-> THE SOFTWARE.  

data/md/obligation.md

@@ -1,32 +0,0 @@
-# Obligation
-
-TBD...
-
-## Copyright
-
-*Concurrent Ruby* is Copyright © 2013 [Jerry D'Antonio](https://twitter.com/jerrydantonio).
-It is free software and may be redistributed under the terms specified in the LICENSE file.
-
-## License
-
-Released under the MIT license.
-
-http://www.opensource.org/licenses/mit-license.php  
-
-> Permission is hereby granted, free of charge, to any person obtaining a copy  
-> of this software and associated documentation files (the "Software"), to deal  
-> in the Software without restriction, including without limitation the rights  
-> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell  
-> copies of the Software, and to permit persons to whom the Software is  
-> furnished to do so, subject to the following conditions:  
-> 
-> The above copyright notice and this permission notice shall be included in  
-> all copies or substantial portions of the Software.  
-> 
-> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR  
-> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,  
-> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE  
-> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER  
-> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  
-> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN  
-> THE SOFTWARE.  

data/md/promise.md

@@ -1,217 +0,0 @@
-# Promises, Promises...
-
-A promise is the most powerful and versatile of the concurrency objects in this library.
-Promises are inspired by the JavaScript [Promises/A](http://wiki.commonjs.org/wiki/Promises/A)
-and [Promises/A+](http://promises-aplus.github.io/promises-spec/) specifications.
-
-> A promise represents the eventual value returned from the single completion of an operation.
-
-Promises are similar to futures and share many of the same behaviours. Promises are far more robust,
-however. Promises can be chained in a tree structure where each promise may have zero or more children.
-Promises are chained using the `then` method. The result of a call to `then` is always another promise.
-Promises are resolved asynchronously in the order they are added to the tree. Parents are guaranteed
-to be resolved before their children. The result of each promise is passed to each of its children
-upon resolution. When a promise is rejected all its children will be summarily rejected.
-
-Promises have three possible states: *pending*, *rejected*, and *fulfilled*. When a promise is created it is set
-to *pending* and will remain in that state until processing is complete. A completed promise is either *rejected*,
-indicating that an exception was thrown during processing, or *fulfilled*, indicating it succeeded. If a promise is
-*fulfilled* its `value` will be updated to reflect the result of the operation. If *rejected* the `reason` will
-be updated with a reference to the thrown exception. The predicate methods `pending?`, `rejected`, and `fulfilled?`
-can be called at any time to obtain the state of the promise, as can the `state` method, which returns a symbol.
-
-Retrieving the value of a promise is done through the `value` (alias: `deref`) method. Obtaining the value of
-a promise is a potentially blocking operation. When a promise is *rejected* a call to `value` will return `nil`
-immediately. When a promise is *fulfilled* a call to `value` will immediately return the current value.
-When a promise is *pending* a call to `value` will block until the promise is either *rejected* or *fulfilled*.
-A *timeout* value can be passed to `value` to limit how long the call will block. If `nil` the call will
-block indefinitely. If `0` the call will not block. Any other integer or float value will indicate the
-maximum number of seconds to block.
-
-Promises run on the global thread pool.
-
-## Examples
-
-Start by requiring promises
-
-```ruby
-require 'concurrent'
-```
-
-Then create one
-
-```ruby
-p = Promise.new("Jerry", "D'Antonio") do |first, last|
-      "#{last}, #{first}"
-    end
-```
-
-Promises can be chained using the `then` method. The `then` method
-accepts a block but no arguments. The result of the each promise is
-passed as the block argument to chained promises
-
-```ruby
-p = Concurrent::Promise.new(10){|x| x * 2}.then{|result| result - 10 }
-```
-
-And so on, and so on, and so on...
-
-```ruby
-p = Concurrent::Promise.new(10){|x| x * 2}.
-    then{|result| result - 10 }.
-    then{|result| result * 3 }.
-    then{|result| result % 5 }
-```
-
-Promises are executed asynchronously so a newly-created promise *should* always be in the pending state
-
-```ruby
-p = Concurrent::Promise.new{ "Hello, world!" }
-p.state   #=> :pending
-p.pending? #=> true
-```
-
-Wait a little bit, and the promise will resolve and provide a value
-
-```ruby
-p = Concurrent::Promise.new{ "Hello, world!" }
-sleep(0.1)
-
-p.state      #=> :fulfilled
-p.fulfilled? #=> true
-p.value      #=> "Hello, world!"
-```
-
-If an exception occurs, the promise will be rejected and will provide
-a reason for the rejection
-
-```ruby
-p = Concurrent::Promise.new{ raise StandardError.new("Here comes the Boom!") }
-sleep(0.1)
-
-p.state     #=> :rejected
-p.rejected? #=> true
-p.reason    #=> "#<StandardError: Here comes the Boom!>"
-```
-
-### Rejection
-
-Much like the economy, rejection exhibits a trickle-down effect. When
-a promise is rejected all its children will be rejected
-
-```ruby
-p = [ Concurrent::Promise.new{ Thread.pass; raise StandardError } ]
-
-10.times{|i| p << p.first.then{ i } }
-sleep(0.1)
-
-p.length      #=> 11
-p.first.state #=> :rejected
-p.last.state  #=> :rejected
-```
-
-Once a promise is rejected it will not accept any children. Calls
-to `then` will continually return `self`
-
-```ruby
-p = Concurrent::Promise.new{ raise StandardError }
-sleep(0.1)
-
-p.object_id        #=> 32960556
-p.then{}.object_id #=> 32960556
-p.then{}.object_id #=> 32960556
-```
-
-### Error Handling
-
-Promises support error handling callbacks is a style mimicing Ruby's
-own exception handling mechanism, namely `rescue`
-
-```ruby
-Concurrent::Promise.new{ "dangerous operation..." }.rescue{|ex| puts "Bam!" }
-
-# -or- (for the Java/C# crowd)
-Concurrent::Promise.new{ "dangerous operation..." }.catch{|ex| puts "Boom!" }
-
-# -or- (for the hipsters)
-Concurrent::Promise.new{ "dangerous operation..." }.on_error{|ex| puts "Pow!" }
-```
-
-As with Ruby's `rescue` mechanism, a promise's `rescue` method can
-accept an optional Exception class argument (defaults to `Exception`
-when not specified)
-
-```ruby
-Concurrent::Promise.new{ "dangerous operation..." }.rescue(ArgumentError){|ex| puts "Bam!" }
-```
-
-Calls to `rescue` can also be chained
-
-```ruby
-Concurrent::Promise.new{ "dangerous operation..." }.
-  rescue(ArgumentError){|ex| puts "Bam!" }.
-  rescue(NoMethodError){|ex| puts "Boom!" }.
-  rescue(StandardError){|ex| puts "Pow!" }
-```
-
-When there are multiple `rescue` handlers the first one to match the thrown
-exception will be triggered
-
-```ruby
-Concurrent::Promise.new{ raise NoMethodError }.
-  rescue(ArgumentError){|ex| puts "Bam!" }.
-  rescue(NoMethodError){|ex| puts "Boom!" }.
-  rescue(StandardError){|ex| puts "Pow!" }
-
-sleep(0.1)
-
-#=> Boom!
-```
-
-Trickle-down rejection also applies to rescue handlers. When a promise is rejected,
-for any reason, its rescue handlers will be triggered. Rejection of the parent counts.
-
-```ruby
-Concurrent::Promise.new{ Thread.pass; raise StandardError }.
-  then{ true }.rescue{ puts 'Boom!' }.
-  then{ true }.rescue{ puts 'Boom!' }.
-  then{ true }.rescue{ puts 'Boom!' }.
-  then{ true }.rescue{ puts 'Boom!' }.
-  then{ true }.rescue{ puts 'Boom!' }
-sleep(0.1)
-
-#=> Boom!
-#=> Boom!
-#=> Boom!
-#=> Boom!
-#=> Boom!
-```
-
-## Copyright
-
-*Concurrent Ruby* is Copyright &copy; 2013 [Jerry D'Antonio](https://twitter.com/jerrydantonio).
-It is free software and may be redistributed under the terms specified in the LICENSE file.
-
-## License
-
-Released under the MIT license.
-
-http://www.opensource.org/licenses/mit-license.php  
-
-> Permission is hereby granted, free of charge, to any person obtaining a copy  
-> of this software and associated documentation files (the "Software"), to deal  
-> in the Software without restriction, including without limitation the rights  
-> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell  
-> copies of the Software, and to permit persons to whom the Software is  
-> furnished to do so, subject to the following conditions:  
-> 
-> The above copyright notice and this permission notice shall be included in  
-> all copies or substantial portions of the Software.  
-> 
-> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR  
-> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,  
-> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE  
-> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER  
-> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  
-> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN  
-> THE SOFTWARE.