Fix English in README (#7)

- librairy → library
- there're → there are
- does not provides → does not provide
- will maybe never be → may never be
- Curently → Currently
- Do not launch → Does not launch
- Computations → Computation
- quantity → amount
- OOM → OOMs
- superior or equal → greater than or equal
- inferior → fewer
- thanks → thank
- writting → writing

Author: guizmaii

README.md

@@ -3,13 +3,13 @@
 Goal
 ----
 
-This librairy helps you to write Excel files (`xlsx`) as fast as possible without, hopefully, blowing your heap.
+This library helps you write Excel files (`xlsx`) as fast as possible without, hopefully, blowing your heap.
 
 It's meant to be used in JRuby programs.    
-It can be used in Scala programs, of course, but there're better, pure, ways with such language to achieve the same goal.
+It can be used in Scala programs, of course, but there are better, pure, ways with such language to achieve the same goal.
 
-It's a very opinionated librairy which does not provides you all the possible customizations.    
-For example, it'll use all your CPU cores to compute the rows, it's not configurable and will maybe never be.
+It's a very opinionated library that does not provide all the possible customizations.    
+For example, it'll use all your CPU cores to compute the rows. It's not configurable and may never be.
 
 Be sure to read and understand the [heap usage considerations](#heap-usage-considerations) and [CPU usage considerations](#cpu-usage-considerations)
 chapters of this README before using this lib in a production environment.
@@ -37,7 +37,7 @@ java_import 'com.colisweb.jruby.concurrent.constant.memory.excel.Cell'
 header     = ["A", "B", "C"].to_java(:string)
 sheet_name = "cars"
 
-# Curently, support only one sheet per workbook.
+# Currently, only one sheet per workbook is supported.
 # 
 workbook_state = ConcurrentConstantMemoryExcel.newWorkbookState(sheet_name, header)
 
@@ -74,64 +74,59 @@ queries.each_with_index { |query, index|
 
   compute_rows_lambda = to_parametrize_compute_rows_lambda.call(query)
 
-  # Do not launch any computation. It just registers required computations in the `workbook_state`.
+  # Does not launch any computation. It just registers required computations in the `workbook_state`.
   #
   # The second argument for this function call should be a lambda taking no parameter.   
   # 
   ConcurrentConstantMemoryExcel.addRows(workbook_state, compute_rows_lambda, index.to_java(:int))
 
 }
 
-# Computations of rows will really begin with this function call. Not before.
+# Computation of rows will really begin with this function call. Not before.
 # 
 ConcurrentConstantMemoryExcel.writeFile(workbook_state, "path/to/my/file") # will write a file named `file.xlsx` in the `path/to/my` directory.
 ```
 
 Heap usage considerations
 -------------------------
 
-This librairy parallelizes the computations of your rows using `n` threads, where `n` is the number of cores your CPU has.
+This library parallelizes the computation of your rows using `n` threads, where `n` is the number of cores your CPU has.
 
 For each call to the `addRows` function, a computation is registered in the `workbook_state`.
 
 When the `writeFile` function is called, all the registered computations will be launched, `n` by `n`.
 
-So the maximum quantity of RAM this lib can use is equal to `n` times the quantity of RAM required to compute the `compute_rows_lambda`.
+So the maximum amount of RAM this lib can use is equal to `n` times the amount of RAM required to compute the `compute_rows_lambda`.
 
-If your program OOM, the only way to fix that is by reducing the size of the result the `query` passed to the `parametrized_compute_rows_lambda` gives you when executed.
+If your program OOMs, the only way to fix that is by reducing the size of the result the `query` passed to the `parametrized_compute_rows_lambda` gives you when executed.
 
 CPU usage considerations
 -------------------------
 
-Because this lib knows nothing about the computations you'll ask it to execute, in order to maximise the CPU usage, 
-and so the speed of your Excel extraction, you'll have to ensure that the number of registered computations (number of call to the `addRows` function)
-is superior or equal to the number of cores your CPU has.
+Because this lib knows nothing about the computations you'll ask it to execute, in order to maximise CPU usage
+and therefore the speed of your Excel extraction, you'll have to ensure that the number of registered computations (number of calls to the `addRows` function)
+is greater than or equal to the number of cores your CPU has.
 
-If it's inferior to that number, maybe you can write your `queries` in a different way.
+If it's fewer than that number, you may be able to write your `queries` in a different way.
 
-For example, instead of making 4 `query` each computing `1000` rows, you can write 8 `query` computing `500` rows.   
-On a 8 cores machines, the result can be computed up to 2 times faster in this case.
+For example, instead of making 4 queries each computing `1000` rows, you can write 8 queries computing `500` rows.   
+On an 8-core machine, the result can be computed up to 2 times faster in this case.
 
 Coding Style
 ------------
 
-This project is a Scala librairy meant to be used in JRuby projects.
+This project is a Scala library meant to be used in JRuby projects.
 
 *That explains the quite impure style used in the Scala code.*
 
 Acknowledgments
 ---------------
 
-We want to thanks:
+We want to thank:
 
  - Nicolas Rinaudo [@NicolasRinaudo](https://twitter.com/NicolasRinaudo)
  - Elijah Rippeth [@terrible_coder](https://twitter.com/terrible_coder)
  - Mathieu Besançon [@matbesancon](https://twitter.com/matbesancon)
  - Charles Oliver Nutter [@headius](https://twitter.com/headius)
 
-for their help in the writting of this lib.
-
-🙂
-
-
- 
+for their help in writing this lib.