• Syntax: Utilizes require to import modules and module.exports or exports to define exports.
• Loading: Synchronous, modules are loaded and executed sequentially.
• Use Cases: Well-suited for server-side applications, especially in Node.js environments where synchronous loading is acceptable.
  
  

• Syntax: Uses import and export statements for importing and exporting modules.
• Loading: Supports asynchronous loading, enabling more efficient loading of modules in browsers.
• Use Cases: Widely used in front-end development due to support in modern browsers. Offers a more standardized syntax and supports advanced features like dynamic
• imports.

type Admin = {
    name: string,
    privileges: string[]
}

type Employee = {
    name: string,
    startDate: Date
}

type CombinedType = Admin & Employee;

interface CombinedInterface extends Admin, Employee { }

const interfaceData: CombinedInterface = { name: '', privileges: [], startDate: new Date() }
const typeData: CombinedType = { name: '', privileges: [], startDate: new Date() }


const handleType = (obj: Record<string, unknown>) => {
    obj['name'] = 42 // unsafe
}


handleType(interfaceData) // error
handleType(typeData) // ok

1. Using git-filter-branch:

git filter-branch --force --index-filter 'git rm --cached --ignore-unmatch <path to the file or directory>' --prune-empty --tag-name-filter cat -- --all

1. Using git-filter-repo:

pip3 install git-filter-repo
git filter-repo --path <path to the file or directory> --invert-paths

git filter-branch --env-filter '
OLD_EMAIL="old-test@test.com"
CORRECT_NAME="Oswaldo Pineda"
CORRECT_EMAIL="new-test@test.com"
if [ "$GIT_COMMITTER_EMAIL" = "$OLD_EMAIL" ]
then
    export GIT_COMMITTER_NAME="$CORRECT_NAME"
    export GIT_COMMITTER_EMAIL="$CORRECT_EMAIL"
fi
if [ "$GIT_AUTHOR_EMAIL" = "$OLD_EMAIL" ]
then
    export GIT_AUTHOR_NAME="$CORRECT_NAME"
    export GIT_AUTHOR_EMAIL="$CORRECT_EMAIL"
fi
' --tag-name-filter cat -- --branches --tags

1. Checking Out the Document: Each friend checks out the document and sees a version number (like "1.0"). This tells them the state of the document when they started.
2. Making Changes: Friends start making changes to the document without telling each other. They trust that conflicts are rare.
3. Checking Back In: Before saving their changes, each friend checks the version number again to make sure nobody else has made changes in the meantime.
4. Conflict Check: If someone else made changes (maybe the version is now "1.1"), it means there's a conflict. Friends are notified, and they need to figure out how to resolve the conflicting changes.
5. Saving Changes: If no conflicts are found, the changes are saved, and everyone's updates are combined.

import { memo } from 'react';
const SomeComponent = memo(function SomeComponent(props) {  // ...});

npm show <package-name>

npm outdated

• Will be cached on most browsers because it's used by a lot of other websites
• Reduce the bandwidth

import $ from 'jQuery'
...
var content = $('#id').html();

• Atomicity: A transaction is made up of multiple statements. Atomicity ensures that either all statements are executed or none are executed.
• Consistency: Consistency ensures that integrity restraints are followed.
• Isolation: Transaction often occurs concurrently, at the same time, and isolation ensures that this does not lead to inconsistent data.
• Durability: Durability ensures that once a transaction is committed, it will remain committed even in the case of a system failure.

git stash list

git stash show

git stash show -p

git stash show -p stash@{1}

git stash show -p 1