Fix various grammatical and spelling mistakes within the docs

doc/design/README.md

@@ -33,12 +33,12 @@ Now let's review features in more detail.
 
 * **Cross-platform compatible.** if same code compiles on Android, PS3 console, and your PC either x64 or x86 architecture, you are 100% sure it works.
 To achieve this, bitsery specifically defines size of underlying data, hence syntax is *value\<2\>* (alias function *value2b*)  instead or *value*, or *container2b* for element type of 16bits, eg int16_t.
-Bitsery also applies endianess transformation if nessesarry.
-* **Flexible syntax.** if you don't like like writing code with explicitly specifying underlying type size, like *container2b* or *value8b* you can use flexible syntax.
+Bitsery also applies endianness transformation if necessary.
+* **Flexible syntax.** If you don't like like writing code with explicitly specifying underlying type size, like *container2b* or *value8b*, you can use flexible syntax.
 Just include <bitsery/flexible.h> and can write like in [cereal](http://uscilab.github.io/cereal/).
-But do it on your own risk, and static assert using *assertFundamentalTypeSizes* function if you're planing to use it accross multiple platforms.
+But do it on your own risk, and static assert using *assertFundamentalTypeSizes* function if you're planing to use it across multiple platforms.
 * **Optimized for speed and space.** library itself doesn't do any allocations (except if you use backward/forward compatibility) so data writing/reading is fast as memcpy to/from your buffer.
-It also doesn't serialize any type information, all information needed is writen in your code!
+It also doesn't serialize any type information, all information needed is written in your code!
 * **No code generation required: no IDL or metadata** since it doesn't support any other formats except binary, it doesn't need any metadata.
 * **Runtime error checking on deserialization** library designed to be save with untrusted network data, that's why all overloads that work on containers has *maxSize* value, unless container is static size like *std::array*, this way bitsery ensures that no malicious data crash you.
 * **Supports forward/backward compatibility for your types** library has optional forward/backward compatibility for types implemented in *AdapterReader/Writer* by allowing to have inner data sessions inside buffer.
@@ -65,5 +65,5 @@ Bitsery allows to use bit-level operations and has two extensions that use them:
 You want to support your custom container, its fine there is *ContainerTraits* for this, only few methods required to implement.
 To use same container for buffer writing/reading add specialization to *BufferAdapterTraits*.
 You want to customize serialization flow - use extensions, only two methods to define, and *ExtensionTraits* to further customize usage.
-* **Configurable endianess support.** default is *Little Endian*, but if your primary target is PowerPC architecture, eg. PlayStation3, just change your configuration to be *Big Endian*.
+* **Configurable endianness support.** default is *Little Endian*, but if your primary target is PowerPC architecture, eg. PlayStation3, just change your configuration to be *Big Endian*.
 * **No macros.** Not so much to say, if you are like me, then it's a feature :)

doc/tutorial/hello_world.md

@@ -2,11 +2,11 @@
 
 This is a quick guide to get **bitsery** up and running in a matter of minutes.
 The only prerequisite for running bitsery is a modern C++11 compliant compiler, such as GCC 4.9.4, clang 3.4, MSVC 2015, or newer.
-Older versions might work, but it is not tested.
+Older versions might work, but they have not been tested.
 
 ## Get bitsery
 
-bitsery can be directly included in your project or installed anywhere you can access header files.
+**bitsery** can be directly included in your project or installed anywhere you can access header files.
 Grab the latest version, and include directory `bitsery_base_dir/include/` to your project.
 There's nothing to build or make - **bitsery** is header only.
 
@@ -27,11 +27,14 @@ using InputAdapter = InputBufferAdapter<Buffer>;
 ```
 
 **bitsery** is very lightweight, so we need to explicitly include what we need.
-* `<bitsery/bitsery.h>` is a core header, that includes our Serializer and Deserializer
-* `<bitsery/adapter/buffer.h>` in order to write/read data we need specific adapter, depending on what underlying buffer will be. In this example we'll be using std::vector as our buffer, so we include buffer adapter.
-* <bitsery/traits/...> traits tells library how efficiently serialize particular container.
 
-create alias types for *InputAdapter* and *OutputAdapter* using our vector as buffer.
+Include  |  Description
+--|--
+`<bitsery/bitsery.h>`  |  This is a core header, that includes our Serializer and Deserializer.
+`<bitsery/adapter/buffer.h>`  |  In order to write/read data, we need a specific adapter, depending on what underlying buffer will be. In this example, we'll be using `std::vector` as our buffer, so we include the buffer adapter.
+`<bitsery/traits/...>`  |  Traits tell the library how to efficiently serialize a particular container. Many common STL containers are supported out of the box.
+
+Create alias types for *InputAdapter* and *OutputAdapter* using our vector as buffer.
 
 ## Add serialization method for your type
 
@@ -124,4 +127,4 @@ int main() {
 }
 ```
 
-**currently documentation and tutorial is progress, but for more usage examples see examples folder**
+**currently documentation and tutorial is progress, but for more usage examples see examples folder**