andreiMirzac1 · August 16, 2016 21:25 · Jun 28, 2016 · Jun 28, 2016 · Jun 28, 2016 · Mar 30, 2016
diff --git a/Antonyms.md b/Antonyms.md
@@ -52,7 +52,7 @@ Positive    | Negative
 `select`    | `deselect`
 `send`      | `receive`
 `serialize` | `deserialize`
-`set`       | `unset` (e.g. a key), `clear` (e.g. a bit)
+`set`       | `unset` (e.g. a key), `clear` (e.g. a bit), `get` (e.g. a value)
 `set up`    | `tear down`
 `show`      | `hide`
 `start`     | `stop`
@@ -62,6 +62,10 @@ Positive    | Negative
 
 # Remarks
 
+## Motivation
+
+Using sensible, consistent wording in APIs improves readability, usability and greatly helps new users getting started. There is nothing more annoying than wondering what a function call is supposed to do while reading (someone else's or your own) code.
+
 ## Initialize
 There is no precise antonym for `initialize` and I don't think there has to be:
 By using `initialize` only for simple initializations that don't need any clean up code

diff --git a/Antonyms.md b/Antonyms.md
@@ -8,6 +8,8 @@ Positive    | Negative
 `advance`   | `retreat`
 `allocate`  | `deallocate` (correct), `free` (common)
 `assemble`  | `disassemble`
+`assign`    | `deassign` (e.g. a task)
+`associate` | `dissociate`
 `attach`    | `detach`
 `begin`     | `end`
 `bind`      | `unbind`
@@ -20,6 +22,7 @@ Positive    | Negative
 `enable`    | `disable`
 `enqueue`   | `dequeue`
 `enter`     | `leave`, `exit`
+`expand`    | `collapse` (e.g. a tree view), `contract`
 `first`     | `last`
 `freeze`    | `unfreeze`
 `front`     | `back`
@@ -36,7 +39,7 @@ Positive    | Negative
 `link`      | `unlink`
 `load`      | `unload` (e.g. a module), `store` (e.g. a value)
 `lock`      | `unlock`
-`minimum`   | `maximum`
+`maximum`   | `minimum`
 `new`       | `old`
 `next`      | `previous`
 `open`      | `close`
@@ -74,6 +77,3 @@ If you still feel like you need an antonym; possibilities include but are not li
 ## "De-" vs. "Un-"
 Both prefixes (`de-` and `un-`) can be defined as a *reversal of action*. Most of the time the prefix `de-` is used for verbs while `un-` is used for adjectives. There are many exceptions to this rule though.
 In some cases careful usage of these prefixes can avoid ambiguity. For example, *"he was unregistered"* is ambiguous because it can mean either *"he was not registered"* or *"his registration was removed"*, while *"he was deregistered"* is not.
-
-## TODO
-`assign`
diff --git a/Antonyms.md b/Antonyms.md
@@ -11,11 +11,11 @@ Positive    | Negative
 `attach`    | `detach`
 `begin`     | `end`
 `bind`      | `unbind`
-`create`    | `destroy`
 `compile`   | `decompile`
 `compress`  | `decompress`
 `connect`   | `disconnect`
 `construct` | `destruct`
+`create`    | `destroy`
 `do`        | `undo`
 `enable`    | `disable`
 `enqueue`   | `dequeue`
@@ -37,13 +37,15 @@ Positive    | Negative
 `load`      | `unload` (e.g. a module), `store` (e.g. a value)
 `lock`      | `unlock`
 `minimum`   | `maximum`
-`next`      | `previous`
 `new`       | `old`
+`next`      | `previous`
 `open`      | `close`
 `push`      | `pop`
 `raise`     | `lower`
 `read`      | `write`
+`reference` | `derefence` (e.g. a pointer), `unreference` (e.g. an object in the case of reference counting)
 `register`  | `deregister`
+`resume`    | `suspend`
 `select`    | `deselect`
 `send`      | `receive`
 `serialize` | `deserialize`
@@ -52,7 +54,6 @@ Positive    | Negative
 `show`      | `hide`
 `start`     | `stop`
 `start up`  | `shut down`, `clean up` (maybe)
-`resume`    | `suspend`
 `up`        | `down`
 `upper`     | `lower`
 
@@ -72,7 +73,7 @@ If you still feel like you need an antonym; possibilities include but are not li
 
 ## "De-" vs. "Un-"
 Both prefixes (`de-` and `un-`) can be defined as a *reversal of action*. Most of the time the prefix `de-` is used for verbs while `un-` is used for adjectives. There are many exceptions to this rule though.
-In some cases careful usage of these prefixes can be used to avoid ambiguity. For example, *"he was unregistered"* is ambiguous because it can mean either *"he was not registered"* or *"his registration was removed"*, while *"he was deregistered"* is not.
+In some cases careful usage of these prefixes can avoid ambiguity. For example, *"he was unregistered"* is ambiguous because it can mean either *"he was not registered"* or *"his registration was removed"*, while *"he was deregistered"* is not.
 
 ## TODO
 `assign`
diff --git a/Antonyms.md b/Antonyms.md
@@ -66,7 +66,7 @@ By using `initialize` only for simple initializations that don't need any clean
 1. establish a convention through that initialization routines without a corresponding clean up routine can be easily recognized, and
 2. circumvent the need for an antonym ;).
 
-For routines that do not fall in this category, select another verb from the table above (most of the time there is a more descriptive alternative anyway).
+For routines that do not fall into this category, select another verb from the table above (most of the time there is a more descriptive alternative anyway).
 
 If you still feel like you need an antonym; possibilities include but are not limited to: `exit` (very common in conjunction with `init`), `reset`, `finalize`, `terminate`.
 

diff --git a/Antonyms.md b/Antonyms.md
@@ -72,4 +72,7 @@ If you still feel like you need an antonym; possibilities include but are not li
 
 ## "De-" vs. "Un-"
 Both prefixes (`de-` and `un-`) can be defined as a *reversal of action*. Most of the time the prefix `de-` is used for verbs while `un-` is used for adjectives. There are many exceptions to this rule though.
-In some cases careful usage of these prefixes can be used to avoid ambiguity. For example, *"he was unregistered"* is ambiguous because it can mean either *"he was not registered"* or *"his registration was removed"*, while *"he was deregistered"* is not.
+In some cases careful usage of these prefixes can be used to avoid ambiguity. For example, *"he was unregistered"* is ambiguous because it can mean either *"he was not registered"* or *"his registration was removed"*, while *"he was deregistered"* is not.
+
+## TODO
+`assign`
diff --git a/Antonyms.md b/Antonyms.md
@@ -1,74 +1,74 @@
 # Antonym List
-*Note: The table headings (positive/negative) are not necessarily correct.*
+*Note: The table headings (positive/negative) are not necessarily meaningful.*
 
 Positive    | Negative
 ------------|------------
-`Acquire`   | `Release`
-`Add`       | `Remove` (e.g. an item), `Subtract` (arithmetic)
-`Advance`   | `Retreat`
-`Allocate`  | `Deallocate` (correct), `Free` (common)
-`Assemble`  | `Disassemble`
-`Attach`    | `Detach`
-`Begin`     | `End`
-`Bind`      | `Unbind`
-`Create`    | `Destroy`
-`Compile`   | `Decompile`
-`Compress`  | `Decompress`
-`Connect`   | `Disconnect`
-`Construct` | `Destruct`
-`Do`        | `Undo`
-`Enable`    | `Disable`
-`Enqueue`   | `Dequeue`
-`Enter`     | `Leave`, `Exit`
-`First`     | `Last`
-`Freeze`    | `Unfreeze`
-`Front`     | `Back`
-`Get`       | `Set`
-`Grant`     | `Revoke`
-`Head`      | `Tail`
-`Import`    | `Export`
-`Increase`  | `Decrease`
-`Increment` | `Decrement`
-`Inflate`   | `Deflate`
-`Inject`    | `Eject`
-`Insert`    | `Delete` (e.g. from a collection), `Extract` (e.g. in a stream)
-`Install`   | `Uninstall`
-`Link`      | `Unlink`
-`Load`      | `Unload` (e.g. a module), `Store` (e.g. a value)
-`Lock`      | `Unlock`
-`Minimum`   | `Maximum`
-`Next`      | `Previous`
-`New`       | `Old`
-`Open`      | `Close`
-`Push`      | `Pop`
-`Raise`     | `Lower`
-`Read`      | `Write`
-`Register`  | `Deregister`
-`Select`    | `Deselect`
-`Send`      | `Receive`
-`Serialize` | `Deserialize`
-`Set`       | `Unset` (e.g. a key), `Clear` (e.g. a bit)
-`SetUp`     | `TearDown`
-`Show`      | `Hide`
-`Start`     | `Stop`
-`StartUp`   | `ShutDown`, `CleanUp` (maybe)
-`Resume`    | `Suspend`
-`Up`        | `Down`
-`Upper`     | `Lower`
+`acquire`   | `release`
+`add`       | `remove` (e.g. an item), `subtract` (arithmetic)
+`advance`   | `retreat`
+`allocate`  | `deallocate` (correct), `free` (common)
+`assemble`  | `disassemble`
+`attach`    | `detach`
+`begin`     | `end`
+`bind`      | `unbind`
+`create`    | `destroy`
+`compile`   | `decompile`
+`compress`  | `decompress`
+`connect`   | `disconnect`
+`construct` | `destruct`
+`do`        | `undo`
+`enable`    | `disable`
+`enqueue`   | `dequeue`
+`enter`     | `leave`, `exit`
+`first`     | `last`
+`freeze`    | `unfreeze`
+`front`     | `back`
+`get`       | `set`
+`grant`     | `revoke`
+`head`      | `tail`
+`import`    | `export`
+`increase`  | `decrease`
+`increment` | `decrement`
+`inflate`   | `deflate`
+`inject`    | `eject`
+`insert`    | `delete` (e.g. from a collection), `extract` (e.g. in a stream)
+`install`   | `uninstall`
+`link`      | `unlink`
+`load`      | `unload` (e.g. a module), `store` (e.g. a value)
+`lock`      | `unlock`
+`minimum`   | `maximum`
+`next`      | `previous`
+`new`       | `old`
+`open`      | `close`
+`push`      | `pop`
+`raise`     | `lower`
+`read`      | `write`
+`register`  | `deregister`
+`select`    | `deselect`
+`send`      | `receive`
+`serialize` | `deserialize`
+`set`       | `unset` (e.g. a key), `clear` (e.g. a bit)
+`set up`    | `tear down`
+`show`      | `hide`
+`start`     | `stop`
+`start up`  | `shut down`, `clean up` (maybe)
+`resume`    | `suspend`
+`up`        | `down`
+`upper`     | `lower`
 
 # Remarks
 
 ## Initialize
-There is no precise antonym for `Initialize` and I don't think there has to be:
-By using `Initialize` only for simple initializations that don't need any clean up code
-(`Initialize` as its own antonym) you can
+There is no precise antonym for `initialize` and I don't think there has to be:
+By using `initialize` only for simple initializations that don't need any clean up code
+(`initialize` as its own antonym) you can
 
 1. establish a convention through that initialization routines without a corresponding clean up routine can be easily recognized, and
 2. circumvent the need for an antonym ;).
 
 For routines that do not fall in this category, select another verb from the table above (most of the time there is a more descriptive alternative anyway).
 
-If you still feel like you need an antonym; possibilities include but are not limited to: `Exit` (very common in conjunction with `Init`), `Reset`, `Finalize`, `Terminate`.
+If you still feel like you need an antonym; possibilities include but are not limited to: `exit` (very common in conjunction with `init`), `reset`, `finalize`, `terminate`.
 
 ## "De-" vs. "Un-"
 Both prefixes (`de-` and `un-`) can be defined as a *reversal of action*. Most of the time the prefix `de-` is used for verbs while `un-` is used for adjectives. There are many exceptions to this rule though.

diff --git a/Antonyms.md b/Antonyms.md
@@ -24,6 +24,7 @@ Positive    | Negative
 `Freeze`    | `Unfreeze`
 `Front`     | `Back`
 `Get`       | `Set`
+`Grant`     | `Revoke`
 `Head`      | `Tail`
 `Import`    | `Export`
 `Increase`  | `Decrease`

diff --git a/Antonyms.md b/Antonyms.md
@@ -16,13 +16,15 @@ Positive    | Negative
 `Compress`  | `Decompress`
 `Connect`   | `Disconnect`
 `Construct` | `Destruct`
+`Do`        | `Undo`
 `Enable`    | `Disable`
 `Enqueue`   | `Dequeue`
 `Enter`     | `Leave`, `Exit`
 `First`     | `Last`
 `Freeze`    | `Unfreeze`
 `Front`     | `Back`
 `Get`       | `Set`
+`Head`      | `Tail`
 `Import`    | `Export`
 `Increase`  | `Decrease`
 `Increment` | `Decrement`
@@ -38,6 +40,7 @@ Positive    | Negative
 `New`       | `Old`
 `Open`      | `Close`
 `Push`      | `Pop`
+`Raise`     | `Lower`
 `Read`      | `Write`
 `Register`  | `Deregister`
 `Select`    | `Deselect`
@@ -50,6 +53,7 @@ Positive    | Negative
 `StartUp`   | `ShutDown`, `CleanUp` (maybe)
 `Resume`    | `Suspend`
 `Up`        | `Down`
+`Upper`     | `Lower`
 
 # Remarks
 

diff --git a/Antonyms.md b/Antonyms.md
@@ -28,7 +28,7 @@ Positive    | Negative
 `Increment` | `Decrement`
 `Inflate`   | `Deflate`
 `Inject`    | `Eject`
-`Insert`    | `Delete`
+`Insert`    | `Delete` (e.g. from a collection), `Extract` (e.g. in a stream)
 `Install`   | `Uninstall`
 `Link`      | `Unlink`
 `Load`      | `Unload` (e.g. a module), `Store` (e.g. a value)

diff --git a/Antonyms.md b/Antonyms.md
@@ -13,6 +13,7 @@ Positive    | Negative
 `Bind`      | `Unbind`
 `Create`    | `Destroy`
 `Compile`   | `Decompile`
+`Compress`  | `Decompress`
 `Connect`   | `Disconnect`
 `Construct` | `Destruct`
 `Enable`    | `Disable`

diff --git a/Antonyms.md b/Antonyms.md
@@ -1,4 +1,5 @@
 # Antonym List
+*Note: The table headings (positive/negative) are not necessarily correct.*
 
 Positive    | Negative
 ------------|------------

diff --git a/Antonyms.md b/Antonyms.md
@@ -25,6 +25,7 @@ Positive    | Negative
 `Increase`  | `Decrease`
 `Increment` | `Decrement`
 `Inflate`   | `Deflate`
+`Inject`    | `Eject`
 `Insert`    | `Delete`
 `Install`   | `Uninstall`
 `Link`      | `Unlink`

diff --git a/Antonyms.md b/Antonyms.md
@@ -60,4 +60,8 @@ By using `Initialize` only for simple initializations that don't need any clean
 
 For routines that do not fall in this category, select another verb from the table above (most of the time there is a more descriptive alternative anyway).
 
-If you still feel like you need an antonym; possibilities include but are not limited to: `Exit` (very common in conjunction with `Init`), `Reset`, `Finalize`, `Terminate`.
+If you still feel like you need an antonym; possibilities include but are not limited to: `Exit` (very common in conjunction with `Init`), `Reset`, `Finalize`, `Terminate`.
+
+## "De-" vs. "Un-"
+Both prefixes (`de-` and `un-`) can be defined as a *reversal of action*. Most of the time the prefix `de-` is used for verbs while `un-` is used for adjectives. There are many exceptions to this rule though.
+In some cases careful usage of these prefixes can be used to avoid ambiguity. For example, *"he was unregistered"* is ambiguous because it can mean either *"he was not registered"* or *"his registration was removed"*, while *"he was deregistered"* is not.
diff --git a/Antonyms.md b/Antonyms.md
@@ -9,8 +9,10 @@ Positive    | Negative
 `Assemble`  | `Disassemble`
 `Attach`    | `Detach`
 `Begin`     | `End`
+`Bind`      | `Unbind`
 `Create`    | `Destroy`
 `Compile`   | `Decompile`
+`Connect`   | `Disconnect`
 `Construct` | `Destruct`
 `Enable`    | `Disable`
 `Enqueue`   | `Dequeue`

diff --git a/Antonyms.md b/Antonyms.md
@@ -6,21 +6,26 @@ Positive    | Negative
 `Add`       | `Remove` (e.g. an item), `Subtract` (arithmetic)
 `Advance`   | `Retreat`
 `Allocate`  | `Deallocate` (correct), `Free` (common)
+`Assemble`  | `Disassemble`
 `Attach`    | `Detach`
 `Begin`     | `End`
 `Create`    | `Destroy`
+`Compile`   | `Decompile`
 `Construct` | `Destruct`
 `Enable`    | `Disable`
 `Enqueue`   | `Dequeue`
-`Enter`     | `Exit`
+`Enter`     | `Leave`, `Exit`
 `First`     | `Last`
 `Freeze`    | `Unfreeze`
 `Front`     | `Back`
 `Get`       | `Set`
 `Import`    | `Export`
 `Increase`  | `Decrease`
 `Increment` | `Decrement`
+`Inflate`   | `Deflate`
 `Insert`    | `Delete`
+`Install`   | `Uninstall`
+`Link`      | `Unlink`
 `Load`      | `Unload` (e.g. a module), `Store` (e.g. a value)
 `Lock`      | `Unlock`
 `Minimum`   | `Maximum`
@@ -32,12 +37,13 @@ Positive    | Negative
 `Register`  | `Deregister`
 `Select`    | `Deselect`
 `Send`      | `Receive`
+`Serialize` | `Deserialize`
 `Set`       | `Unset` (e.g. a key), `Clear` (e.g. a bit)
 `SetUp`     | `TearDown`
 `Show`      | `Hide`
 `Start`     | `Stop`
 `StartUp`   | `ShutDown`, `CleanUp` (maybe)
-`Suspend`   | `Resume`
+`Resume`    | `Suspend`
 `Up`        | `Down`
 
 # Remarks

diff --git a/Antonyms.md b/Antonyms.md
@@ -14,8 +14,8 @@ Positive    | Negative
 `Enqueue`   | `Dequeue`
 `Enter`     | `Exit`
 `First`     | `Last`
-`Front`     | `Back`
 `Freeze`    | `Unfreeze`
+`Front`     | `Back`
 `Get`       | `Set`
 `Import`    | `Export`
 `Increase`  | `Decrease`

diff --git a/Antonyms.md b/Antonyms.md
@@ -15,6 +15,7 @@ Positive    | Negative
 `Enter`     | `Exit`
 `First`     | `Last`
 `Front`     | `Back`
+`Freeze`    | `Unfreeze`
 `Get`       | `Set`
 `Import`    | `Export`
 `Increase`  | `Decrease`

diff --git a/Antonyms.md b/Antonyms.md
@@ -51,4 +51,4 @@ By using `Initialize` only for simple initializations that don't need any clean
 
 For routines that do not fall in this category, select another verb from the table above (most of the time there is a more descriptive alternative anyway).
 
-If you feel like you need an antonym anyway; possibilities include but are not limited to: `Exit` (very common in conjunction with `Init`), `Reset`, `Finalize`, `Terminate`.
+If you still feel like you need an antonym; possibilities include but are not limited to: `Exit` (very common in conjunction with `Init`), `Reset`, `Finalize`, `Terminate`.
diff --git a/Antonyms.md b/Antonyms.md
@@ -47,7 +47,7 @@ By using `Initialize` only for simple initializations that don't need any clean
 (`Initialize` as its own antonym) you can
 
 1. establish a convention through that initialization routines without a corresponding clean up routine can be easily recognized, and
-2. circumvent the need for a antonym ;).
+2. circumvent the need for an antonym ;).
 
 For routines that do not fall in this category, select another verb from the table above (most of the time there is a more descriptive alternative anyway).
 

diff --git a/Antonyms.md b/Antonyms.md
@@ -44,7 +44,7 @@ Positive    | Negative
 ## Initialize
 There is no precise antonym for `Initialize` and I don't think there has to be:
 By using `Initialize` only for simple initializations that don't need any clean up code
-(`Initialize` as it's own antonym) you can
+(`Initialize` as its own antonym) you can
 
 1. establish a convention through that initialization routines without a corresponding clean up routine can be easily recognized, and
 2. circumvent the need for a antonym ;).

diff --git a/Antonyms.md b/Antonyms.md
@@ -44,7 +44,7 @@ Positive    | Negative
 ## Initialize
 There is no precise antonym for `Initialize` and I don't think there has to be:
 By using `Initialize` only for simple initializations that don't need any clean up code
-you can
+(`Initialize` as it's own antonym) you can
 
 1. establish a convention through that initialization routines without a corresponding clean up routine can be easily recognized, and
 2. circumvent the need for a antonym ;).

diff --git a/Antonyms.md b/Antonyms.md
@@ -49,6 +49,6 @@ you can
 1. establish a convention through that initialization routines without a corresponding clean up routine can be easily recognized, and
 2. circumvent the need for a antonym ;).
 
-For routines that do not fall in this category, select another verb from the table above (most of the time there is a more descriptive verb anyway).
+For routines that do not fall in this category, select another verb from the table above (most of the time there is a more descriptive alternative anyway).
 
 If you feel like you need an antonym anyway; possibilities include but are not limited to: `Exit` (very common in conjunction with `Init`), `Reset`, `Finalize`, `Terminate`.
diff --git a/Antonyms.md b/Antonyms.md
@@ -49,4 +49,6 @@ you can
 1. establish a convention through that initialization routines without a corresponding clean up routine can be easily recognized, and
 2. circumvent the need for a antonym ;).
 
+For routines that do not fall in this category, select another verb from the table above (most of the time there is a more descriptive verb anyway).
+
 If you feel like you need an antonym anyway; possibilities include but are not limited to: `Exit` (very common in conjunction with `Init`), `Reset`, `Finalize`, `Terminate`.
diff --git a/Antonyms.md b/Antonyms.md
@@ -45,6 +45,7 @@ Positive    | Negative
 There is no precise antonym for `Initialize` and I don't think there has to be:
 By using `Initialize` only for simple initializations that don't need any clean up code
 you can
+
 1. establish a convention through that initialization routines without a corresponding clean up routine can be easily recognized, and
 2. circumvent the need for a antonym ;).
 

diff --git a/Antonyms.md b/Antonyms.md
@@ -0,0 +1,51 @@
+# Antonym List
+
+Positive    | Negative
+------------|------------
+`Acquire`   | `Release`
+`Add`       | `Remove` (e.g. an item), `Subtract` (arithmetic)
+`Advance`   | `Retreat`
+`Allocate`  | `Deallocate` (correct), `Free` (common)
+`Attach`    | `Detach`
+`Begin`     | `End`
+`Create`    | `Destroy`
+`Construct` | `Destruct`
+`Enable`    | `Disable`
+`Enqueue`   | `Dequeue`
+`Enter`     | `Exit`
+`First`     | `Last`
+`Front`     | `Back`
+`Get`       | `Set`
+`Import`    | `Export`
+`Increase`  | `Decrease`
+`Increment` | `Decrement`
+`Insert`    | `Delete`
+`Load`      | `Unload` (e.g. a module), `Store` (e.g. a value)
+`Lock`      | `Unlock`
+`Minimum`   | `Maximum`
+`Next`      | `Previous`
+`New`       | `Old`
+`Open`      | `Close`
+`Push`      | `Pop`
+`Read`      | `Write`
+`Register`  | `Deregister`
+`Select`    | `Deselect`
+`Send`      | `Receive`
+`Set`       | `Unset` (e.g. a key), `Clear` (e.g. a bit)
+`SetUp`     | `TearDown`
+`Show`      | `Hide`
+`Start`     | `Stop`
+`StartUp`   | `ShutDown`, `CleanUp` (maybe)
+`Suspend`   | `Resume`
+`Up`        | `Down`
+
+# Remarks
+
+## Initialize
+There is no precise antonym for `Initialize` and I don't think there has to be:
+By using `Initialize` only for simple initializations that don't need any clean up code
+you can
+1. establish a convention through that initialization routines without a corresponding clean up routine can be easily recognized, and
+2. circumvent the need for a antonym ;).
+
+If you feel like you need an antonym anyway; possibilities include but are not limited to: `Exit` (very common in conjunction with `Init`), `Reset`, `Finalize`, `Terminate`.