fix grammer module database devops

Author: MuhtasimTanmoy

database/cockroachdb.md

@@ -2,10 +2,10 @@
 
 ![](./screen/CockroachDB.png)
 
-- `CockroachDB` is mainly a distributed, replicated, transactional  key value store.
+- `CockroachDB` is mainly a distributed, replicated, transactional key-value store.
 
 - [The Challenges of Writing a Massive and Complex Go Application](https://youtu.be/hWNwI5q01gI)
     - Design decisions while building cockroachDB
-    - Gc cost is based on number of allocations, not number of bytes
-    - Values thst are used together can be allocated in one struct
+    - Gc cost is based on the number of allocations, not the number of bytes
+    - Values that are used together can be allocated in one struct
     - [Incomplete]

database/elastic search.md

@@ -5,47 +5,47 @@
 - Elastic Search forms with index
 - Index (Logical namespace / DB Name)
     - Divided into Shrads (Types / Table / Schema)
-- Each shrad has replica
-- Each shrad is Lucene index
+- Each shard has replica
+- Each shard is Lucene index
     - For inverted search
 - Divided into Segments
     - Inverted index
 - Segments are immutable
-- Apache lucene
+- Apache Lucene
     - Powerful open-source full-text search library
 - DB normalize
-    - Case dispose, punctuation
+    - Case disposal, punctuation
     - Common word remove    
     - Stop word list
     - Lemma
         - Mapping different usage to one
 - Tokenization
-    -  Stemming > Buying > Buy
+    - Stemming > Buying > Buy
 - After 1 second index refresh happens
     - Doc indexed
 - Translog (30 min or 512mb)
 - Master node and Data Node available
 
 - Inverted index
-    - A document is the unit of data in Elasticsearch and an inverted index is created by tokenizing the terms in the document, creating a sorted list of all unique terms and associating a list of documents with where the word can be found.
+    - A document is the unit of data in Elasticsearch and an inverted index is created by tokenizing the terms in the document, creating a sorted list of all unique terms, and associating a list of documents with where the word can be found.
       - Record level inverted index (word -> record)
       - Word level inverted index (word -> record, position )
 
 ### Internal Usage
 - Porters stemmer algo
     - The Porter stemming algorithm (or ‘Porter stemmer’) is a process for removing the commoner morphological and inflexional endings from words in English. 
-    - Its main use is as part of a term normalisation process that is usually done when setting up Information Retrieval systems.
+    - Its main use is as part of a term normalization process that is usually done when setting up Information Retrieval systems.
 - Murmur3 hash function
 - Why indexing?
-    - Database blocks stored like linked list
+    - Database blocks stored like a linked list
     - For searching  N blocks 
         - when not sorted searching requires `N/2` access avg
         - when duplicates then `N`
         - when sorted `logN`
 
 ### Database Indexing
 
-- Creating an index on a field in a table creates another data structure which holds the field value, and a pointer to the record it relates to. 
+- Creating an index on a field in a table creates another data structure that holds the field value and a pointer to the record it relates to. 
 
 - This index structure is then sorted, allowing Binary Searches to be performed on it.
 
@@ -64,13 +64,13 @@
         - All records map to index
     - Sparse index
         - Few records map to sorted index
-    - Sparse index not possible if records not organized/sorted
+    - Sparse index is not possible if records are not organized/sorted
 
 - Graph database which considers relation and data 
 secondary index
 
 ### Notes
-- Low cardinality in database 
+- Low cardinality in the database 
     - Common attribute
     - Easy for indexing
 - Made efficient through bitmap indexing

database/embedded database.md

@@ -1,51 +1,51 @@
 # Embedded Database
 
 ### Level DB
-- Has too much mutex contension
+- Has too much mutex contention
 - Bitcoin core, go ethereum uses it
 - Sqlite used in past chrome, now uses leveldb
 - Has different fork `rocksdb`, `hyperLevelDB`
 
 ### RocksDB
 - Log Structured Merge Tree
 - MemTable / SSTable
-- InnoDB used in mySQL
+- InnoDB used in MySQL
 
 ### References
 - [DropBox Engineering Evening on RocksDB with Dhruba Borthakur @ Rockset](https://www.youtube.com/watch?v=aKAJMd0iKtI&ab_channel=DhrubaBorthakur)
 
 - [Embedded Database: RocksDB](youtube.com/watch?v=V_C-T5S-w8g)
-    - Shows benchmark between sqlite, levelDB, kyoto TreeDB
+    - Shows benchmark between SQLite, level DB, Kyoto TreeDB
     - `LevelDB` was good at random reads and random write
-    - In LSM database, the amount of data you can write directly proportional to how fast you can compact.
-    - `Bloom filter` not very useful when you do range caps
+    - In the LSM database, the amount of data you can write is directly proportional to how fast you can compact.
+    - The `Bloom filter` is not very useful when you do range caps
     - Prefix Scan for locality search
-        - Range scans with same key prefix
+        - Range scans with the same key prefix
         - Blooms created for prefix
         - Reduce read amplification
-    - Thread aware compaction used on top of leveldb
-    - `Write amplification` change. Compared to how many bytes you write to the database, how many times it needs to be re written
+    - Thread-aware compaction used on top of leveldb
+    - `Write amplification` change. Compared to how many bytes you write to the database, how many times it needs to be re-written
     - `Read amplification` resolved
     - `Read modify write`
 
 - [RockDB internals](https://www.youtube.com/watch?v=aKAJMd0iKtI)
     - Everything is pluggable
-    - Each block has index and filter block
-        - Each block has starting and end index in block to perform binary search
+    - Each block has an index and filter block
+        - Each block has a starting and end index in block to perform a binary search
         - Database shadowing
 
 - [RocksDB Port](https://youtu.be/jGCv4r8CJEI)
     - MySQL, Mongo to use rocksdb as storage engine
 
 - [LSM Tree](https://www.youtube.com/watch?v=V1iqN2ie__w)
     - `b+ tree` used when we need less search and insertion time
-    - `lsm tree` when we have write intensive dataset
+    - `lsm tree` when we have written an intensive dataset
     - Write 0(1), Read logn
     - Four key concepts
-        - wal - write ahead log
-        - memtable - batching write
+        - wal - write-ahead log
+        - memorable - batching write
         - compaction - making efficient
         - bloom filters - to discard, make query efficient
 
-- [LSM based Storage Techniques Strengths and Trade Offs (SDC 2019)](https://www.youtube.com/watch?v=V1iqN2ie__w)
+- [LSM-based Storage Techniques Strengths and Trade-Offs (SDC 2019)](https://www.youtube.com/watch?v=V1iqN2ie__w)
     - To Be Continued

database/mnesia.md

@@ -1,26 +1,26 @@
 # Mnesia
 
-- Mnesia combines many concepts found in traditional databases such as transactions and queries with concepts found in data management systems for telecommunications applications such as very fast realtime operations, configurable degree of fault tolerance (by means of replication) and the ability to reconfigure the system without stopping or suspending it.
+- Mnesia combines many concepts found in traditional databases such as transactions and queries with concepts found in data management systems for telecommunications applications such as very fast real-time operations, configurable degree of fault tolerance (using replication), and the ability to reconfigure the system without stopping or suspending it.
 
 - Mnesia is also interesting due to its tight coupling to the programming language Erlang, thus almost turning Erlang into a database programming language.
 
-- This has many benefits, the foremost being that the impedance mismatch between data format used by the DBMS and data format used by the programming language which is being used to manipulate the data, completely disappears.
+- This has many benefits, the foremost being that the impedance mismatch between the data format used by the DBMS and the data format used by the programming language that is being used to manipulate the data, completely disappears.
 
-- Mnesia has four methods of reading from database: read, match_object, select, qlc.
-    - `read` always uses a Key-lookup on the keypos. It is basically the key-value lookup.
+- Mnesia has four methods of reading from the database: read, match_object, select, qlc.
+    - `read` always uses a key lookup on the key position. It is the key-value lookup.
     - `match_object` and select will optimize the query if it can on the keypos key. That is, it only uses that key for optimization. It never utilizes further index types.
-    - `qlc` has a query-compiler and will attempt to use additional indexes if possible, but it all depends on the query planner and if it triggers. erl -man qlc has the details and you can ask it to output its plan.
+    - `qlc` has a query compiler and will attempt to use additional indexes if possible, but it all depends on the query planner and if it triggers. Erl -man qlc has the details and you can ask it to output its plan.
 - read is just a `key-value` lookup, also functions `index_read` and `index_write`
 
 - A power of two number of fragments is simply related to the fact the default fragmentation module `mnesia_frag` uses linear hashing so using `2^n` fragments assures that records are equally distributed (more or less, obviously) between fragments.
 
 - Using `disc_only_copies` most of the time is spent in two operations:
     - Decide which fragment holds which record
-    - Retrieve the record from corresponding dets table (Mnesia backend)
+    - Retrieve the record from the corresponding dets table (Mnesia backend)
 
 - `DCD` and `DCL` files represent `disc_copies` tables. The `DCD` is an image of the contents from the latest time the table was "dumped", while the `DCL` contains a log of the side-effects made to that table since it was dumped. A dump creates a new `DCD` and removes the `DCL`.
 
-- `DAT` files are `DETS:es` which contain `disc_only_copies` tables.
+- `DAT` files are `DETS: es` which contain `disc_only_copies` tables.
 
 - `SCHEMA.DAT` is a special DETS that contains the schema for that Mnesia instance.
 
@@ -29,15 +29,15 @@
 - Applies argument `Fun` to all records in the table. 
 - `Fun` is a function that takes a record of the old type and returns a transformed record of the new type. 
 - Argument `Fun` can also be the atom ignore, which indicates that only the metadata about the table is updated. 
-- Use of ignore is not recommended, but included as a possibility for the user do to an own transformation.
+- Use of ignore is not recommended but included as a possibility for the user do to their own transformation.
 
 - `NewAttributeList` and `NewRecordName` specify the attributes and the new record type of the converted table. 
 
 - Table name always remains unchanged. If `record_name` is changed, only the Mnesia functions that use table identifiers work, for example, `mnesia:write/3` works, but not `mnesia:write/1`.
 
-- A good solution could be to have more fragments and less records per fragment but trying at the same time to find the middle ground and not lose the advantages of some hard disk performance boosts like buffers and caches.
+- A good solution could be to have more fragments and fewer records per fragment but trying at the same time to find the middle ground and not lose the advantages of some hard disk performance boosts like buffers and caches.
 
-- Very often start with a few `ETS` tables when prototyping (or even on early versions of features in production), then start finding places I need data serialized and on disk, then realize I need multiple indexes, etc. and wind up moving a lot of the data management stuff that was initially in ETS into Mnesia anyway. 
+- Very often start with a few `ETS` tables when prototyping (or even on early versions of features in production), then start finding places I need data serialized and on disk, then realize I need multiple indexes, etc., and wind up moving a lot of the data management stuff that was initially in ETS into Mnesia anyway. 
 
 - If abstracted away the concept of data access properly it is not an issue to change the implementation of this part of your system either way. 
 

database/mongoDB.md

@@ -1,6 +1,6 @@
 # NoSQL
 
-- No SQL duplicates but first read fast write slow but read write ration `7000:1`
+- No SQL duplicates but first read fast write slow but read-write ratio `7000:1`
 Cloud firestore
 
-- Uses ` WiredTiger storage engine`
+- Uses ` WiredTiger storage engine

database/mysql.md

@@ -2,11 +2,11 @@
 
 ![](./Screen/Database.png )
 
-- `Mysql` has nine storage engine.
+- `Mysql` has nine storage engines.
     - `InnoDB` locks record level
     - `MYSIum`
 
 - In Memory database uses `AVL tree`
-    - Used highly in real time header bidding to show advertisement
+    - Used highly in real-time header bidding to show an advertisement
 - Relational database uses `B+ tree`
-- Set uses `Red black tree`
+- Set uses `Red Black Tree`

database/sqlite.md

@@ -1,6 +1,6 @@
 # SQLite
 
-- An `application file format` is the file format used to persist application state to disk or to exchange information between programs. It's alternative is `fopen`.
+- An `application file format` is the file format used to persist application state to disk or to exchange information between programs. Its alternative is `fopen`.
 
 - `file format` vs `application format` 
 
@@ -10,42 +10,42 @@
 
 - Sqlite file is application format.
 
-### Full Text Search
-- FTS3 has smaller file, slower search
-- FTS4 has bigger file, faster search
+### Full-Text Search
+- FTS3 has a smaller file, a slower search
+- FTS4 has bigger files, faster search
 
 - rowID
     - Integer Primary Key highly optimized
 
 - Isolation
     - Journal mode
         - Changes are written directly into the database file
-        - while simultaneously a separate rollback journal file is constructed that is able to restore the database to its original state if the transaction rolls back. 
+        - while simultaneously a separate rollback journal file is constructed that can restore the database to its original state if the transaction rolls back. 
         - Two times write.
         - In rollback mode, SQLite implements isolation by locking the database file and preventing any reads by other database connections while each write transaction is underway.
-        - Readers can be be active at the beginning of a write, before any content is flushed to disk and while all changes are still held in the writer's private memory space. 
-        - But before any changes are made to the database file on disk, all readers must be (temporally) expelled in order to give the writer exclusive access to the database file.
-        - Readers are prohibited from seeing incomplete transactions by virtue of being locked out of the database while the transaction is being written to disk. 
+        - Readers can be active at the beginning of a write before any content is flushed to disk and while all changes are still held in the writer's private memory space. 
+        - But before any changes are made to the database file on disk, all readers must be (temporally) expelled to give the writer exclusive access to the database file.
+        - Readers are prohibited from seeing incomplete transactions by being locked out of the database while the transaction is being written to disk. 
         - Only after the transaction is completely written and synced to disk and commits are the readers allowed back into the database. 
         - Hence readers never get a chance to see partially written changes.
 
     - [WAL mode](https://www.sqlite.org/wal.html)
         - WAL mode permits simultaneous readers and writers. 
         - It can do this because changes do not overwrite the original database file, but rather go into the separate write-ahead log file. 
-        - It means that readers can continue to read the old, original, unaltered content from the original database file at the same time that the writer is appending to the write ahead log. 
+        - It means that readers can continue to read the old, original, unaltered content from the original database file at the same time that the writer is appending to the write-ahead log. 
         - In WAL mode, SQLite exhibits "snapshot isolation". 
         - When a read transaction starts, that reader continues to see an unchanging `snapshot` of the database file as it existed at the moment in time when the read transaction started. 
-        - Any write transactions that commit while the read transaction is active are still invisible to the read transaction, because the reader is seeing a snapshot of database file from a prior moment in time.
+        - Any write transactions that commit while the read transaction is active are still invisible to the read transaction because the reader is seeing a snapshot of the database file from a prior moment in time.
 
 - Without file param used as `in memory` database.
 
-- Functional difference between STORED columns cannot be added using the `ALTER TABLE ADD COLUMN` command.
+- Functional differences between STORED columns cannot be added using the `ALTER TABLE ADD COLUMN` command.
 
 - Only VIRTUAL columns can be added using `ALTER TABLE`.
 
-- Strict Typed tables more common though dynamic type used by default in sqlite. If a type is not convertible then it stores as that.
+- Strict Typed tables are more common though dynamic type used by default in SQLite. If a type is not convertible then it stores as that.
 
-- Partial indexing used in many case.
+- Partial indexing is used in many cases.
 
 - The life-cycle of a prepared statement object usually goes like this:
     - Create the prepared statement object using `sqlite3_prepare_v2()`.
@@ -54,7 +54,7 @@
     - Reset the prepared statement using `sqlite3_reset()` then go back to step 2. Do this zero or more times.
     - Destroy the object using `sqlite3_finalize()`.
 
-- SQLite `vaccum` command optimizes size.
+- SQLite `vacuum` command optimizes size.
 
 ### References
 - [VFS](https://www.sqlite.org/vfs.html)

database/time series db.md

@@ -1,4 +1,4 @@
-# Time series Database
+# Time Series Database
 
 ### References
 - [InfluxDB Storage Engine Internals | Metamarkets](https://www.youtube.com/watch?v=rtEalnKT25I)