Misc Technical Definitions

Intro

A growing collection of technical terms and their definitions. I've found that I tend to know stuff but not its name. Speaking the correct terms is always important in conveying the message across. So, I'll be trying to keep a list of terms that I tend to forget hoping they come in handy someday.

Backend

1. Index

   Searching any data becomes much faster if the data is sorted (think binary search, we can stop early, etc). An index is a data structure that holds pointers to the original data but is sorted; so we don't actually sort the data but keep a sorted copy at hand. It makes writing new data a bit slower and takes additional space but hey searching now becomes much faster.

2. Clustered Index

3. NonClustered Index

4. Normalization

   Is a process for reducing data redundancy and increasing its integrity (less chance of inserting inconsistent data). This is a very well-defined and academic process as outlined in the normal forms.

5. Normal Forms

   To satisfy a form, all forms below it must be satisfied first. Satisfying all the third normal form is what we usually refer to as a normalized database.

   1. First Normal Form: Data is atomic; i.e. a column cannot be broken down into sub-columns. No lists nor
   2. Second Normal Form: All columns depends on the key in its entirety; no column should depend on a subset of the key
   3. Third Normal Form: All columns depends only on the key; no column depend on another non-key column.

6. DeNormalization

   Is a process to increase the read performance at the expense of write performance. Basically we add redundant data in some table to allow us to retrieve it later without joins.

Frontend

1. Hoisting (Javascript)

   Although javascript is an interpreted language, the compiler performs a first pass through the code (taking note of variables defined with var and functions) then actually executing the code on the 2nd pass. Hence, during the 2nd pass, all var defined variables will be undefined in their function block (yes, before they are actually declared) and while functions will have their declaration ready. When using let or const instead of var, variables are still hoisted, but they are not initialized to undefined.

2. Coercion (Javascript)

   Javascript terms for type casting. The reason why 1 + true = 2; true is coerced into 1 and 1+1 = 2. That's why we should use === for comparisons since it doesn't coerce. Note that in JS, only the following 6 values are falsy:

   1. false
   2. 0
   3. "" and ''
   4. null
   5. undefined
   6. NaN

3. Debouncing

   Originating from electrical engineering, bouncing is the tendency of any two metal contacts to generate multiple signals as the contacts open or close. Debouncing is what we do to make sure only one signal is received.

General Algorithms, Data Structures & Design Patterns

1. Shamir's Secret Sharing

   A form of secret sharing where the secret is divided into parts and minimum of N (i.e. threshold) parts is required to reconstruct the original secret. Note that if any number of parts < N is compromised, then we can be sure that the secret have not been compromised yet.

2. Thundering herd problem

   When a number of processes (or threads) where all waiting for a particular resource and all are awoken at the same time and start competing for that shared resource while only one of them is allowed to consume that resources at that time.

3. HATEOAS

   Hypertext As The Engine Of Application State; All future actions that a client may takes are discovered with resource representation return from the service. In plain english, included with the returned data are all the links for further actions to be taken against this same resource. The classic example for this is a bank account the returns on GET all links to the deposit, transfer, withdraw and close but if the account is overdrawn, then only deposit will be returned to indicate that it is the only allowed operation for the current account state.

4. SOLID

   • Single responsibility principle: A class should have only a single responsibility
   • Open-Closed principle: software entities should be open for extension and closed for modification.
   • Liskov substitution principle: Objects should be replaceable with their subtypes.
   • Interface Segregation principle: Many client-specific interfaces is better that one general purpose interface
   • Dependency Injection principle: depend upon abstractions not concretions.

5. Big O

   The language and metric used to describe the efficiency of algorithms. We use it for both Time and Space complexity. Don't forget for each algorithm, there are three cases; Best, Worst, and Expected.

6. Robustness principle/Postel's law

   When it comes to API design, Be conservative in what you send, be liberal in what you accept; output the minimum and no more and consume what you need and discard the rest.

7. Canary deployment

   Also known as blue/green, red/black, or purple/red deployment, is the idea of releasing a new version of an application and only allowing a small percentage of traffic to reach it.