Update changelog for 2.0

2 files changed, 53 insertions, 3 deletions

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3dc4946..9937ac4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,53 @@
+# v2.0.0
+
+Lots of changes here! The biggest feature is modularization.  You can now `require("async/series")` to only require the `series` function.  Every Async library function is available this way.  You still can `require("async")` to require the entire library, like you could do before.
+
+We also provide Async as a collection of ES2015 modules. You can now `import each from 'async-es'` or `import waterfall from 'async-es/waterfall'`.  If you are using only a few Async functions, and are using a ES bundler such as Rollup, this can significantly lower your build size.
+
+Major thanks to @Kikobeats and @megawac for doing the majority of the modularization work, as well as @jdalton and @Rich-Harris for advisory work on the general modularization strategy.
+
+ANother one of the general themes of the 2.0 release is standardization of what an "async" function is.  We are now more strictly following the node-style continuation passing style.  That is, an async function is a function that:
+
+1. Takes a variable number of arguments
+2. The last argument is always a callback
+3. The callback can accept any number of arguments
+4. The first argument passed to the callback will be treated as an error result, if the argument is truthy
+5. Any number of result arguments can be passed after the "error" argument
+6. The callback is called once and exactly once, either on the same tick or later tick of the JavaScript event loop.
+
+There were several cases where Async accepted some functions that did not strictly have these properties, most notably `auto`, and `every`/`some`/`filter`.
+
+Another theme is performance.  We have eliminated internal deferrals in all cases where they make sense.  For example, in `waterfall` and `auto`, there was a `setImmediate` between each task -- these deferrals have been removed.  A `setImmediate` call can add up to 1ms of delay. This might not seem like a lot, but it can add up if you are using many Async functions in the course of processing a HTTP request, for example.  Nearly all asynchronous functions that do I/O already have some sort of deferral built in, so the extra deferral is unnecessary.  The trade-off of this change is removing our built-in stack-overflow defense. Many synchronous callback calls in series can quickly overflow the JS call stack.  If you do have a function that is sometimes synchronous (calling its callback on the same tick), and are running into stack overflows, wrap it with `async.ensureAsync()`.
+
+## New Features
+
+- Async is now modularized.  Individual functions can be `require()`d from the main package. (`require('async/auto')`) (#696)
+- Async is also available as a collection of ES2015 modules in the new `async-es` package.  (`import forEachSeries from 'async-es'`) (#696)
+- Added `race`, analogous to `Promise.race()`. It will run an array of async tasks in parallel and will call its callback with the result of the first task to respond. (#568, #1038)
+- Added `timeout`, a wrapper for an async function that will make the task time-out after the specified time. (#1007, #1027)
+- `constant` supports dynamic arguments -- it will now always use its last argument as the callback. (#1016, #1052)
+- `setImmediate` and `nextTick` now support arguments to partially apply to the deferred function, like the node-native versions do. (#940, #1053)
+- Added `autoInject`, a relative of `auto` that automatically spreads a task's dependencies as arguments to the task function. (#608, #1055)
+- You can now limit the concurrency of `auto` tasks. (#635, #637)
+- Added `q.unsaturated` -- callback called when a `queue`'s number of running workers falls below a threshold. (#868, #1030, #1033, #1034)
+
+## Breaking changes
+
+- Calling a callback more than once is considered an error, and an error will be thrown.  This had an explicit breaking change in `waterfall`. If you were relying on this behavior, you should more accurately represent your control flow as an event emitter or stream. (#814, #815, #1048, #1050)
+- `auto` task functions now always take the callback as the last argument.  If a task has dependencies, the `results` object will be passed as the first argument. To migrate old task functions, wrap them with [`_.flip`](https://lodash.com/docs#flip) (#1036, #1042)
+- Internal `setImmediate` calls have been refactored away. This may make existing flows vulnerable to stack overflows if you use many synchronous functions in series. Use `ensureAsync` to work around this. (#696, #704, #1049, #1050)
+- `filter`, `reject`, `some`, `every`, and related functions now expect an error as the first callback argument, rather than just a simple boolean. Pass `null` as the first argument, or use `fs.access` instead of `fs.exists`. (#118, #774, #1028, #1041)
+- `{METHOD}` and `{METHOD}Series` are now implemented in terms of `{METHOD}Limit`.  This is a major internal simplification, and is not expected to cause many problems, but it does subtly affect how functions execute internally. (#778, #847)
+- `retry`'s callback is now optional.  Previously, omitting the callback would partially apply the function, meaning it could be passed directly as a task to `series` or `auto`.
+
+## Other
+
+- Added `someSeries` and `everySeries` for symmetry, as well as a complete set of `any`/`anyLimit`/`anySeries` and `all`/`/allLmit`/`allSeries` aliases.
+- Added `find` as an alias for `detect`  (as well as `findLimit` and `findSeries`).
+- Various doc fixes (#1005, #1008, #1010, #1015, #1021, #1037)
+
+------------------------------------------
+
 # v1.5.2
 - Allow using `"constructor"` as an argument in `memoize` (#998)
 - Give a better error messsage when `auto` dependency checking fails (#994)
@@ -80,7 +130,7 @@ Bug Fixes:
 
 Bug Fix:
 
-- Small regression with synchronous iterator behavior in `eachSeries` with a 1-element array.  Before 1.1.0, `eachSeries`'s callback was called on the same tick, which this patch restores.  In 2.0.0, it will be called on the next tick.  (#782) 
+- Small regression with synchronous iterator behavior in `eachSeries` with a 1-element array.  Before 1.1.0, `eachSeries`'s callback was called on the same tick, which this patch restores.  In 2.0.0, it will be called on the next tick.  (#782)
 
 
 # v1.1.0
@@ -92,7 +142,7 @@ New Features:
 - Optimized `map`, `eachOf`, and `waterfall` families of functions
 - Passing a `null` or `undefined` array to `map`, `each`, `parallel` and families will be treated as an empty array (#667).
 - The callback is now optional for the composed results of `compose` and `seq`. (#618)
-- Reduced file size by 4kb, (minified version by 1kb) 
+- Reduced file size by 4kb, (minified version by 1kb)
 - Added code coverage through `nyc` and `coveralls` (#768)
 
 Bug Fixes:
diff --git a/README.md b/README.md
index 2b9dcb6..734e1aa 100644
--- a/README.md
+++ b/README.md
@@ -201,7 +201,7 @@ Some functions are also available in the following forms:
 * [`detect`](#detect), `detectSeries`, `detectLimit`
 * [`sortBy`](#sortBy)
 * [`some`](#some), `someLimit`, `someSeries`
-* [`every`](#every), `everyLimit`, `someSeries`
+* [`every`](#every), `everyLimit`, `everySeries`
 * [`concat`](#concat), `concatSeries`
 
 ### Control Flow