Update README.md

Author: elgopher

README.md

@@ -20,8 +20,8 @@ Thanks to this small library, you can create relatively simple code without the
 Normally a web application is using following pattern to modify data in the database:
 
 1. **Load resource** from database. Resource is some portion of data 
-such as record, document etc. Lock the entire resource pessimistically
-or optimistically (by reading version number).
+such as set of records from relational database, document from Document-oriented database or value from KV store.
+Lock the entire resource pessimistically or optimistically (by reading version number).
 2. **Apply change** to data
 3. **Save resource** to database. Release the pessimistic lock. Or run
 atomic update with version check (optimistic lock).
@@ -37,7 +37,7 @@ Because a single resource is loaded and saved thousands of times per second
 we can instead:
 
 1. Load the resource **once** (let's say once per second) 
-2. Execute all the requests from this period of time on an already loaded resource. Run them all sequentially.
+2. Execute all the requests from this period of time on an already loaded resource. Run them all sequentially to keep things simple and data consistent.
 3. Save the resource and send responses to all clients if data was stored successfully.
 
 Such solution could improve the performance by a factor of 1000. And resource is still stored in a consistent state. 
@@ -51,14 +51,15 @@ processor := batch.StartProcessor(
     batch.Options[*YourResource]{ // YourResource is your own Go struct
         MinDuration:  100 * time.Millisecond,
         LoadResource: func(ctx context.Context, resourceKey string) (*YourResource, error){
-			// resourceKey uniquely identifies the resource
-			...
+            // resourceKey uniquely identifies the resource
+            ...
         },
         SaveResource: ...,
     },
 )
 
-// Following code is run from http/grpc handler:
+// And use the processor inside http/grpc handler or technology-agnostic service.
+// ResourceKey can be taken from request parameter.
 err := s.BatchProcessor.Run(resourceKey, func(r *YourResource) {
     // Here you put the code which will executed sequentially inside batch  
 })
@@ -72,18 +73,19 @@ For real-life example see [example web application](_example).
 # Add batch to your Go module:
 go get github.com/elgopher/batch
 ```
-Please note that at least **Go 1.18** is required.
+Please note that at least **Go 1.18** is required. The package is using generics, which was added in 1.18. 
 
 ## Scaling out
 
-Single Go http server is able to handle up to tens of thousands of requests per second on a commodity hardware. This is a lot, but very often you also need:
+Single Go http server is able to handle up to tens of thousands of requests per second on a commodity hardware. 
+This is a lot, but very often you also need:
 
 * high availability (if one server goes down you want other to handle the traffic)
-* you want to handle hundred thousands or millions of requests per second
+* you want to handle hundred-thousands or millions of requests per second
 
 For both cases you need to deploy **multiple servers** and put a **load balancer** in front of them. 
 Please note though, that you have to carefully configure the load balancing algorithm. 
-Round-robin is not an option here, because sooner or later you will have problems with locking 
+_Round-robin_ is not an option here, because sooner or later you will have problems with locking 
 (multiple server instances will run batches on the same resource). 
 Ideal solution is to route requests based on parameters or URL. 
 For example some http parameter could be a resource key. You can instruct load balancer