Please enable JavaScript.

Coggle requires JavaScript to display documents.

Software Development (WiP) (Desktop (Terminal (Basic Commands (File…

- - - - Scripting languages
        
        JavaScript
        
        Node.js
        Asynchronous event-driven JavaScript runtime
        
        Best Practices
        
        Cheatsheet
        
        Express / Koa / Hapi (Server Framework)
        
        npm
        Node Package Manager
        
        Beginner's Guide
        
        CLI
        
        Libraries registry
        
        Tools
        
        Prettier (Formatter)
        
        ESLint (Linter)
        
        Jest / Mocha - Chai / Lab - Code / Sinon / Cucumber (Testing)
        
        TypeScript (Type enabled JS superset)
        
        Libraries
        
        Knex / Objection / Sequelize (Database)
        
        Pino / Winston / Bunyan (Logging)
        
        Python
        
        Libraries
        
        SQLAlchemy (Database)
        
        Marshmallow (Data formatting)
        
        Flask / Django (Web Framework)
        
        Environment
        
        Pipenv (package/env manager, alternative to pip/venv combo)
        
        Makefile (Building automation tool)
        
        pip (Package Installer) / venv (Virtual Environment)
        
        Tools
        
        flake8 (Linter)
        
        Alembic (Database migration)
        
        yapf (Formatter)
        
        Gunicorn (Server runner)
      - High Performance Languagues
        
        Go
        
        Rust
        
        Swift
      - Functional Languagues
        
        OCaml
        
        Reason
        
        Elixir / Haskell / Scala / Clojure
      - Java / Kotlin / PHP / C# (.NET) / Ruby / F# / R
    - - Message Brokers
        
        ZeroMQ
        
        Kafka
        
        RabbitMQ
      - Caching
        
        Redis
        
        Cassandra
      - Analytics / Search
        
        ElasticSearch
      - Relational DB
        
        PostgreSQL
        
        Microsoft SQL Server
        
        SQLite
        
        MySQL
      - NoSQL
        
        MongoDB
        
        Couchbase / RethinkDB
    - - Security
        OWASP Top Ten (2021)
        
        Injection
        Untrusted data is sent to an interpreter as part of a command or query, leading to the execution of unintended commands or unauthorized access
        Remediation: Parameterized queries or prepared statements, input validation, and proper encoding
        
        Identification and Authentication Failures
        Unauthorized individuals are allowed to compromise user accounts, passwords, or session tokens
        
        Cryptographic Failures
        
        Broken Access Control
        
        Security Misconfiguration
        
        Vulnerable and Outdated Components
        
        Insecure Design
        
        Software and Data Integrity Failures
        
        Security Logging and Monitoring Failures
        
        Server-Side Request Forgery
      - API Design
        
        Application Programming Interface
        
        What is an API?
        
        Error Handling
        Handling a failing request by sending the appropriate status code and error message.
        E.g: HTTP 400 { "error": "B01", "message": "The request parameters are invalid" }
        
        Authentication
        Allowing access to resources via valid API keys, OAuth, or JWT (JSON Web Tokens)
        
        HTTP
        See: Computer Science > Networking
        
        Authorization
        Allowing access to ressources via rules based on user roles, permissions, or scopes
        
        Versioning & Documentation
        Providing a thorough document describing the API versioning mechanism, resources (routes), expected input & output and potential errors codes & meaning
      - Scalability / Performance
        
        Multi-Threading / Clustering
        Optimizing the use of cpus through native multi-threading (C++) or a clustering tool (Node cluster, Python Gunicorn) [Vertical Scaling]
        
        Load Balancing
        Using a dedicated tool (Nginx, Kubernetes) to distribute network requests to a series of identical nodes based on the current load capacity of those nodes [Horizontal Scaling]
        
        Database Query Optimization
        Identifying long processing or frequently used database queries and implementing solutions such as using database views, read-only clones, improving the query or the database schema
        
        Caching
        Saving frequently used assets (data, images) into a fast-access dataset (Redis) to avoid unnecessary calls to Database
        
        Asynchronous processing
        Identifying long processing code flow and separating it into another process (worker) that communicates with the main process using message broker (RabbitMQ, Python Celery)
        
        Cron
        Having dedicated server(s) running periodic jobs with the goal of maintaining/cleaning/helping a part of the system
        
        Micro-Services
        Identifying large and/or complex parts of the application that could be extracted into another server, a series of micro-servers, or individual lambda functions in order to scale and maintain independently
        
        Rate Limiting & Throttling
        Ensure fair usage and prevent abuse of API ressources by controlling the number of requests allowed within a specific timeframe
      - Reliability
        
        Monitoring
        
        Error Logging
        Using the Common Logging system to print out detailed messages about an error that occurred in the system to allow for debug or diagnostic of a potential issue.
        
        Common Logging
        Following an app lifecycle by printing messages that give out essential information on what happened, when, who was involved.
        Preferably JSON based (e.g pino) & levelled (info warn, error)
        
        Performance/Resource Tracking
        Proving metrics to an external tool (e.g NewRelic) to learn about a system's capabilities & performance
        
        Telemetry / Tracing
        Following a request data (logs, metrics, traces) throughout multiple connected services (e.g api - third party - database)
        
        Fault tolerance
        Prevent interruption of service by implementing server restarting mechanisms (e.g load balancing, replica set, clustering)
        
        Error Handling
        Forwarding errors upward to the system level to ensure logging complete error data and preventing server from crashing
      - Database Design
        
        Data Modeling
        Defining the structure, relationships, and constraints of the data entities within the system
        
        Database Management System (DBMS)
        Selecting the appropriate database technology for the system requirements
        E.g: Relational (PostgreSQL, MySQL), NoSQL (MongoDB, Cassandra)
        
        Optimizations
        
        Normalization
        Decomposing a table into multiple smaller tables and defining relationships between them, to minimize data duplication and improve data integrity
        Happens in steps known ad Normal Forms: 1NF, 2NF, 3NF, BCNF, 4NF, 5NF
        
        Indexing
        Improve the performance of database queries by creating data structures (indexes) that allow for quick data retrieval.
        It involves choosing the appropriate columns to index, adjust them over time and potentially reindexing periodically to continuously improve performances
        
        Query Optimizations
        Understanding query execution plans, analyzing query performance, and employing techniques such as indexing, query rewriting, caching, and denormalization to enhance query efficiency
        
        Database Security
        Implementing authentication/authorization mechanisms, encrypting data at rest/in-transit and following security best practices to prevent unauthorized data access
        
        Migration & Versioning
        Managing changes to the database structure over time, while data consistency and minimal downtime
        
        Data Governance and Compliance
        Adhering to data governance principles and complying with legal and regulatory requirements (e.g GDPR, HIPAA)
        
        Data Backup and Recovery
        Ensuring data durability and availability by implementing regular data backup and designing disaster recovery plans
        
        Transactions and Concurrency Control
        Ensuring integrity and consistency of data by grouping multiple database operations into a single logical unit, managing isolation levels and concurrency
      - Authentication
        
        Intro to IAM
        
        Differences between protocols
        
        OAuth 2
        A standard designed to allow an application to access resources hosted by other web apps on behalf of a user, so they don't need to share their credentials. OAuth 2 uses an Access Token to access resources on behalf of the end-user
        
        OIDC
        An identity protocol that utilizes the authorization and authentication mechanisms of OAuth 2.0. It is often used to identify users and provide SSO capabilities
        
        SAML
        An open standard created to provide cross-domain single sign-on (SSO). It allows a user to authenticate in a system and gain access to another system by providing proof of their authentication
    - - API Patterns
        
        REST
        
        Uniform interface
        Uniquely identify each resource involved in the interaction between the client and the server.
        E.g HTTP-method + route: POST /my/route
        
        Layered System
        Layers of an API can point to different resources in the system while presenting a unique interface
        E.g: /api/topic1 -> server 1; /api/topic2 -> server 2
        
        Stateless
        Each request contains all the necessary information to process the request.
        The data layer (db, cache) is separated from the logic layer.
        
        Client-Server
        Separation between the client (webpage, app) and the server. So they can be replaced and developed independently, as long as the interface between them is compatible
        
        Cacheable
        A client can reuse the data based on the request cache labels set by the server
        
        SOAP
        
        GraphQL
        
        Queries & Mutations
        
        Schema & Types
        
        Implementation Example
        
        gRPC
      - Micro-Services
        
        Decomposes the system into smaller, loosely coupled services that communicate with each other via APIs calls
        
        Pros: Scalability, independent development and deployment of services, fault isolation, and technology flexibility for each service
        
        Cons: Increased complexity due to distributed nature, additional overhead in managing inter-service communication, potential performance issues with remote calls
        
        Recommendation: Ideal use for medium to big systems. Drawbacks need to be addressed as the system scales. Using a combination of micro, serverless and event-driven architecture is a good way to address various scale issues
      - Serverless
        
        Focus on writing code without managing infrastructure. Backend logic is implemented as functions (e.g AWS Lambda) that are triggered by events
        
        Pros: Scalability and elasticity, reduced operational overhead, pay-per-use pricing model, rapid development and deployment
        
        Cons: Limited control over infrastructure, potential vendor lock-in, performance impacts due to cold starts (initial function invocation latency)
        
        Recommendation: Ideal for a team with little DevOps experience or for running specific async jobs that don't need to live in the main Backend system
      - Monolith
        
        The entire system is built as a single, self-contained application
        
        Pros: Simplicity, easy development and testing and direct access to all components
        
        Cons: Lack of scalability, difficulty in maintaining and deploying updates, potential for a single point of failure
        
        Recommendation: Ideal use for MVPs and small projects, as the system expends, other types of Architecture should be considered
      - Event-Driven
        
        Handles processes based on events and asynchronous messaging. Events trigger actions and allow communication between components
        
        Pros: Loose coupling, scalability, responsiveness to real-time events, flexibility in adding or modifying components
        
        Cons: Complexity in managing event flows, potential issues with event ordering and consistency, debugging and testing challenges
        
        Recommendation: Can be used to aid micro-services to scale and handle async tasks. The complexity of the even flows need to often be monitored and reviewed
      - Event Sourcing and CQRS
        
        Event sourcing captures and stores all changes to the application state as a sequence of events. CQRS separates the read and write models for improved scalability and flexibility
        
        Pros: Auditability, traceability, scalability, real-time analytics, ability to rebuild state from events
        
        Cons: Increased complexity, additional infrastructure requirements, potential challenges in maintaining consistency across read and write models
      - File Structures
        
        Monolithic
        All the code and resources of the system reside within a single project or directory. Often used in simpler applications or early MVPs
        
        Layered
        Separates the code and ressources by layer following architecture pattern:
        Presentation layer - Business logic layer - Data layer
        Similar to, but not exactly same as, MVC (Model View Controller) structure
        
        Component Based
        Each component/module has its own directory, containing all the necessary code and resources related to that component
        
        Feature Based
        Each feature has its own directory, containing all the related code and resources
        
        Modular (packages)
        Packages represent logical divisions of code within the system, often aligned with features or functional grouping. They can be worked on and tested individually, as well as reused throughout the project (e.g CLI, API, tests)
        
        These file structures can be used together and complement each other, as long as consistency and understandability is maintained throughout the project
  - - - HTML
        
        Document - <!DOCTYPE html>, <html>, <head>, <body>
        
        Basic Elements - <div>, <a>, <p>, <img>, <h1>, <h2>, <table>, etc.
        
        Element Attributes - id, class, style, etc.
        
        Head
        
        Meta - <title>, <base>, <meta>
        
        CSS - <style>, <link rel="stylesheet">
        
        JavaScript - <script>
        
        Forms - <form>, <input>, <select>, <textarea>, etc.
      - CSS
        
        Basic Syntax - selector { property: value; }
        
        Layout - Position, Table, Float, Flexbox, Grid, Bootstrap/Foundation framework
        
        Selectors
        
        Basic - element, .class, #id
        
        Nested - .class .other-class, .class > .child
        
        Properties
        
        Box - display, margin, padding, height/width, border
        
        Text - color, font-family, font-size, font-weight, text-align, text-decoration, text-transform
        
        Layout - float, position, flex, grid
      - JavaScript
        
        DOM (Document Object Model)
        
        Query Elements - document - getElementById, querySelector
        
        Modify Elements - element - innerHTML, innerText, attribute, style
        
        Update Elements - document - createElement, remove/append/replaceChild
        
        Element Events - element - onclick, onfocus, onload, etc.
        
        Language Basics
        
        Syntax - Conditions, Comparisons, Variables, Operators, Functions
        
        Data types - Number, Object, String, Array, Boolean, Date
        
        Advanced - JSON, Math, RegExp, Class, Promise/Async-Await
        
        BOM (Browser Object Model)
        
        window - screen, location, history, navigator, alert, setTimeout, setInterval etc.
    - - JavaScript
        
        Frameworks
        
        Vue
        
        Angular
        
        React
        
        Tools
        
        create-react-app (app bootstrap)
        
        Apollo (GraphQL)
        
        React Router (Navigation)
        
        Next.js (Server-Side Rendered Apps) / Gatsby (static content website)
        
        Concepts
        
        Stateless Components
        
        Hooks
        
        JSX
        
        Props Flow
        
        Virtual DOM (applying changes to DOM only when needed)
        
        Tools
        
        Jest / Mocha - Chai / Testing Library (Testing)
        
        Prettier (Formatter)
        
        ESLint (Linter)
        
        TypeScript (Type enabled JS superset)
        
        Storybook (Documentation, Playground)
        
        Puppeteer / Playwright / Cypress / Selenium (E2E Testing, comparison)
        
        Redux / MobX (State management)
        
        Rx.js, Immutable.js, Ramda (Functional Programming)
        
        Webpack / Parcel / Vite
        
        Advanced concepts
        
        PWA (Progressive Web App)
        
        Providing enhanced capabilities for website to act more like native apps (geolocation, notification, device info, etc.)
        
        What can PWA do today?
        
        Storage - Persisting data across navigation and page reload (session, local, cookies, indexDB)
        
        Web Sockets (Native, socket.io)
        
        Service Workers - Running JS in the background without affecting the page's performance
        
        AJAX - Async request to a server (XMLHttpRequest, fetch)
        
        Testing / Debugging
        
        Developer console, E2E testing
        
        JavaScript Testing and Debugging Tools
      - Elm / ReScript
      - Dart / PureScript / ClojureScript / Haxe / Nim
    - - Frameworks
        
        Native - Using flexbox or grid
        
        Bootstrap / Foundation
        
        Materialize
        
        Bulma / Tailwind / Skeleton
      - Organization
        
        BEM
        
        SMACSS
        
        Atomic
        
        CSS-in-JS
        
        Styled Components
      - Precompilers
        
        SASS / LESS / Stylus
        
        PostCSS
    - - User Experience
        
        Accessibility
        Designing for a diverse set of users (font size, contrast, dictation software, etc.)
        
        Responsive Design
        Designing for a diverse set of devices (laptop, phone, tablet, etc.)
        
        Performance
        Offering a smooth user experience within the app (navigation, sync/async interactions, caching, etc.)
        
        Consistency
        Maintaining a consistent style guide for the whole app/platform
        
        Internationalization
        Allowing an user to navigate the app/platform in the language they feel the most comfortable with
        
        Cross Browser/Platform Compatibility
        Ensuring compatibility across different browsers (e.g. Chrome, Firefox, Safari) and platforms (e.g., Windows, macOS, mobile devices)
      - Security
        
        Input validation
        Making sure the data sent to the backend has been pre-screened for errors and security concerns
        
        Preventing Cross-Site Scripting
        Through unsanitized input, an user can potentially run code on another user's machine
        
        Error handling
        Providing meaningful messages to the user and clear recovery steps when something goes wrong on the app or on the Backend
        
        HTTPS
        Serving the website over HTTPS to protect user's data and prove that the website is trustworthy
      - SEO (Search Engine Optimization)
        
        A process of improving positions in organic (non-paid) search results in search engines
        
        Learn SEO
      - Performance Optimization
        
        JS/CSS minifying, image optimization, cashing, request and file compression, http2
        
        FEO Guidelines
      - SPA
        
        Component-Based Architecture
        
        State
        
        Sync with Backend
        
        Router
        
        Client Side Authentication
        Taking the user through an authentication flow before showing the app's data. Interacting with APIs via authentication tokens (e.g JWT)
        
        Efficient Rendering
        
        Resource loading Optimization
      - Automated Testing
        Writing testable components. Performing unit, integration tests on the codebase. Performing end-2-end tests on the system
  - - - Container
        
        Kubernetes
        
        Kubernetes is an open-source system for automating deployment, scaling, and management of containerized applications
        
        Tools
        
        helm (cli & charts to package a kubernetes app)
        
        minikube / k3d + k9s (local setup)
        
        kubectl (kubernetes cli)
        
        Concepts
        
        Service discovery (ingress) and load balancing
        
        Automated rollouts and rollbacks (update deployments, kubectl rollout)
        
        Automatic bin packing (make the best use out of available resources)
        
        Self-healing - restarts/replace/kill containers that fail (Deployment + ReplicaSet)
        
        Secret and configuration management (Secrets, ConfigMaps)
        
        Storage orchestration (Volumes, PV, PVC)
        
        Container orchestration (Pod, StatefulSet, Jobs, CronJobs)
        
        Role Based Access Control (Role, RoleBinding)
        
        Docker
        
        Client
        
        Dockerfile
        Configuration file to build a new image
        
        docker-compose
        CLI & config file to run all the services for a given app (backend, worker, frontend) alongside all its dependencies (postgres, redis, etc.)
        
        Docker CLI
        Perform docker actions from the terminal
        E.g: docker pull/ push / build / run
        
        Engine / Deamon
        
        Registry / Hub
        
        Containers offer a logical packaging mechanism in which applications can be abstracted from the environment in which they actually run
      - Cloud Platforms
        
        Small-Medium
        
        Heroku
        
        DigitalOcean / Vultr / UpCloud / Back4App / ...
        
        Dokku (self-hosted mini-Heroku)
        
        Medium-Big
        
        AWS
        
        EC2 / ECS / EKS (Deployment)
        
        S3 (Storage)
        
        CloudFront (CDN)
        
        SQS (Queue)
        
        SNS (Notifications)
        
        Lambda (Serverless functions)
        
        RDS / Aurora / DynamoDB (Database)
        
        VPC / KMS / Cognito
        
        IAM (Identity fo AWS)
        
        Azure
        
        Google Cloud Platform
        
        Specialised Services
        
        Shopify (e-commerce)
        
        Firebase (realtime db & analytics)
        
        PubNub (realtime communication & notifications)
        
        IaC
        Infrastructure as Code
        
        Terraform
        
        Ansible
        
        Chef / Puppet / Cloud specific (e.g AWS CloudFormation)
    - - Delivery
        
        CI/CD Pipelines
        
        (self-hosted) Jenkis
        
        Github Actions
        
        TeamCity / GitLab CI / Codeship / DroneCI / Bamboo / Buddy / GoCD / ...
        
        CircleCI
        
        Travis
        
        Continuous Integration (CI)
        
        Linking automated actions to a code repository's commits/merges
        
        Performing tests and code quality (linter, static analyser) controls in a sandbox environment
        
        Making sure the code passes a series of test before being merged to a repository's main branch
        
        Continuous Delivery (CD)
        
        Using CI jobs to make sure the code is deployment ready
        
        Building/Packaging the code into a library (npm, pip) or image (docker)
        
        Publishing the package/image into a remote repository (npm, pypi, docker hub)
        
        Deploying the code/image into a dev/staging/production environment
        
        Release/Rollback Strategies
        
        onDelete / Recreate
        Remove old version then deploy new one
        
        rollingUpdate / Ramped
        Gradually deploy new replicas while removing the old ones
        
        Blue/green
        Deploy new version together with old one, then switch when ready
        
        Canary
        New version for some users then full rollout when ready
      - Reliability
        
        SLOs
        (Service Level Objectives)
        
        Monitoring
        
        (Flientd, Splunk, etc.) Logging
        
        (NewRelic, Dynatrace) App Performance
        
        System perfomance
        
        Chaos Engineer
        
        Error Budgets
        
        Incident Management & Postmortems
      - Testing
        
        Pen-Tests
        Running a series of specific tests designed to find security vulnerabilities in a deployed system. Ideally run before any release that adds a new public ressource (e.g API route)
        
        End-2-End
        Running a series of tests over the entire system to make sure that user flows are working properly.
        Ideally those are run before a release, as well as periodically (CI job) on a deployed environment (dev, stg, qa)
        
        Unit / Integration
        Running a series of tests over the whole codebase, before code merge and releases, to control code quality and prevent bugs.
        Usually ran as part of the CI flow
        
        Testing Environments
        Setting up environments where tests can be performed without affecting Production data & availability
        
        Development: Dev team internal testing
        
        Staging: Production clone with anonymized data
        
        QA: Optional extra env for a dedicated QA team to perform tests
      - Security
        
        HTTPS
        
        Network Config
        
        DDOS Protection (CloudFlare)
        
        Dependency vulnerability tracking
      - Configuration & Dependencies Management
        
        Dependencies tracking & upgrade
        
        Service configuration tracking and update
    - - Plan
      - Code
      - Build
      - Test
      - Release
      - Deploy
      - Operate
      - Monitor
- - - - Platforms
        
        GitLab / Bitbucket
        Offer similar features as GitHub
        
        GitHub
        
        Teams
        Organize individual contributors for different access level (e.g admins, developers, testers, etc.)
        
        Repositories
        
        Issues
        Notes for improvement suggestion, feature request or general support & discussion
        
        Pull-Requests (PR)
        Review code changes before merging them to a another branch
        
        Access-Management
        Control Read/Write/Admin access for teams and individual collaborators
        
        Event Hooks
        Send notification to a third party systems to monitor or assist GitHub processes (PRs, issues, deployments, etc.)
        
        Branch Protection
        Define a set of rules to protect the branches from unwanted or potential hazardous actions (force push, delete, direct push, etc.)
        
        Branches, Commits, Tags
        
        Fork
        Duplicating a repo in order to make a contribution back to the main repo or to create a new system based on that initial repo
        
        Releases
        Using a git tag to describe a release. Usually includes changes description and release notes
        
        Organizations
        
        Projects
        Organize and track issues and PRs in a Kanban/Scrum board
      - Concepts
        
        Clone
        Pull an entire repo from a remote origin into a local folder
        
        Push & Pull
        Push/apply changes to a remote origin (may require to pull latest changes beforehand)
        Pull latest changes from a remote origin (may require conflict resolution)
        
        Hooks
        Allow for a process to run upon a git lifecycle event (e.g running a linter before committing a code change)
        
        Repo, Branch, Commit, Tag, Merge
    - - Branching
        Organize code by features or environments (e.g master, dev, feature/xyz, hotfix/xyz, release/123)
      - Audit trail
        Track what was changed and who made the change at any point in the history of the repository
      - Team collaboration
        Allow for multiple individuals to work on the same project at the same time and allowing for 'easy' merging of various contributions
      - Merging
        Allow for contributions (made in a branch) to be merged into the main system (via a main branch eg. master). Usually requires code conflicts resolution.
      - Repository
        A container for a codebase and its history, branches, commits, etc.
      - Tagging
        Marking a specific commit as a significant point of the history of a repo (e.g versioning: v1.0, v.2.3.4, etc.)
      - Commits
        A single contribution made to a branch that can contain any number of code changes. A series of commits makes up the history of a repo
    - - Monolith
      - Multi-Repos
      - Monorepo
      - Managed Multi-Repos (gita, mani)
  - - - VSCode / Atom / Sublime Text / etc.
      - IntelliJ IDEA
      - (Native Platform) XCode / Android Studio
    - - SoutreTree
      - GitHub Desktop / Tower / etc.
    - - Chrome / Firefox / Safari
      - Edge / Opera / Internet Explorer / etc.
    - - Postman
      - Chrome DevTools
    - - Package Manager
        
        (Mac) Homebrew
        
        (Linux) apt-get / apk / yum
        
        (Windows) winget
      - Terminal
        
        iTerm + zsh
        
        Mac Terminal / Terminator + Sh / Bash / Fish
      - Language Manager
        
        pyenv / nodenv
        
        swift / openjdk / go / opam
      - Container
        
        (Docker) docker / docker-compose
        
        (Kubernetes) k3d + k9s + kubectl + helm
      - Automation
        
        (Request) curl
        
        (Parser) jq / yq
      - Data
        
        psql
        
        vault
    - - ChatGPT
      - Copilot
- - - - File System
        
        (file/folder listing) ls / tree / find
        
        (file display) cat / head / tail / less / more
        
        (physical location) pwd / cd
        
        (folder manipulation) mkdir / rmdir / rm -R
        
        (file manipulation) cp / mv / touch / rm
      - (result manipulation) grep / sort / uniq / sed
      - (file editor) vi(m) / nano / emacs
      - (running a command as the root/admin user) sudo
      - (process manipulation) ps / top / kill
      - (file permissions) ls -l / chmod / chown
      - (manual/documentation of local commands) man
    - - (list env variables) env
      - (create new variable) export A_VAR=123
      - (use variable in command) echo $A_VAR
      - Important Variables
        
        (env variable that defines where the commands are found) PATH
        
        (where the home directory is located) HOME
        
        (where the current terminal is located) PWD
        
        (current user) USER
      - (create variable only for one command line) DEBUG=1 a_cmd
    - - (Wildcards / Tilde / Dot / Redirection / Pipe)
    - - alias
      - PATH
      - Custom Functions
    - - (stdin) Collecting user input
      - (stdout) Commands log
      - (stderr) Commands error log
- - - - Presenting an Interactive View (Presenter / View Controller)
        The goal of a native app is to present an information to an user, via a dedicated container/view, and allow that user to interact with that view in order to perform a specific action.
        A view can be anything as simple as a text-box or an input (Button, Text Input), a view containing other views or a complex interactive component such as a map.
      - Collecting User Inputs
        The app should be able to present an interactive view and react to the user inputs on that view.
        For example, when presenting a button, the app should known that the button was tapped and perform an action based on the purpose of that button.
        On a more complex component like a map, the app should be able to react to all the different inputs from the user (zoom, move around, tap on a spot, recenter on current position, etc.)
      - Synchronising with the Backend (Network Controller)
        On user input, an app can be asked to perform an action that impacts the remote data connected to that app (e.g get a list of article, create a new article).
        On such action, the app should be able to make a request to a remote database (via a Backend) and collect the data from a successful call, or the error from a failed call.
      - Storing Data Locally (Model)
        Upon a successful Backend request or during an user input, the app may need to store some information for a later use.
        This is usually done via the use of a local database (e.g SQLIte) and used in code via a Model type object
      - Coordinating the Presented Data (Coordinator / Interactor)
        When presenting information to the user via a view, the app may need to collect, curate and/or transform the data before it it presented.
        This usually involves gathering data from the local storage, the Backend or a mix of both and curating/transforming that data based on the view's needs.
      - Coordinating the Flow of Views (Router / Flow Controller)
        Defining the interactions between different views to create a user journey.
        To achieve this in iOS for example, one could use a Storyboard or a custom NavigationController
        E.g (Sign in flow): Welcome View > Sign Up View > Onboarding View > App Main View
      - Updating the View based on changes (State)
        After presenting the view, the app should be able to update that view or parts of it based on external changes.
        For example: User sees a list of articles > User taps Refresh button > Request to Backend > Request is successful
        
        In this example, the initial state is a list of articles, as well as a 'none' loading status
        
        When the request starts, the loading status changes to 'loading', so the view updates to display a loading indicator
        
        When the request succeeds, the loading status would change to 'none', the loading indicator is hidden, and the list of articles is replaced by the list received by the Backend
    - - Swift
      - Objective-C
    - - XCode
        
        Code Editor
        
        Interface Builder
        
        Runner / Debugger
        
        Managing Project Properties
      - Cocoapods
        
        Manage Project workspace & dependencies via cli & Podfile
        
        Install packages from the community & link them to the project
        
        Create packages and distribute them to the community
      - App Store Connect
        
        TestFlight
        
        Manage Internal Testers and test builds
        
        Manage External Testers and beta builds
        
        Manage Product Page
        
        Manage Releases & Updates
        
        Manage In-App Purchases
        
        Insights & Analytics
        
        Role Access Management
      - Fastlane (Deployment CLI)
      - swift-format lint / SwiftLint (Linter)
      - swift-format / SwiftFormat (Formatter)
      - R.swift / SwiftGen (Code Generator)
    - - Core
        
        UIKit
        
        Views / Controls
        
        Collection / Table / Stack / Scroll / Image / Text / Label / Web
        
        Button / TextField / Progress Indicator / Pickers / Switchers / Sliders / Page Control / Segmented Control
        
        Concepts
        
        Auto-Layout
        
        Storyboards
        
        View / View Hierarchy
        
        ViewControllers
        
        NavigationControllers
        
        ...
        
        CoreData
        
        Foundation
        
        Queue / Operations
        
        Primitive Types (String, Array, Dictionary, etc.)
        
        File System
        
        User Defaults
        
        JavaScriptCore
        
        SwiftUI
        
        CryptoKit / ARKit / CloudKit / HealthKit / HomeKit
        
        GCD (Concurrency Dispatch)
        
        XCTest
        
        Core ML / Core Audio / Core Graphics / Core Image / Core Location / Core Media / Core Motion / Core Video
      - 3rd Party
        
        Alamofire (Network, alternative to Foundation's URLSession)
        
        Realm (Database, alternative to CoreData)
        
        PromiseKit
        
        KingFisher / Nuke (Image caching/processing)
        
        ReactiveCocoa / RxSwift (Reactive Programming)
    - - MVC
        
        Model
        Data as an object. Contains the business logic related to that entity
        
        View
        Container for the information presented to the user (e.g UILabel, UIView)
        
        Controller
        Handles everything else listed in the Responsibilities (e.g UIViewController, UINavigationController)
      - MVVM
        
        Model
        (same as for MVC)
        
        View
        Manages the views and the user inputs (e.g UIViewController)
        
        View-Model
        Object attached to a View, which has the responsibilities of coordinating the data to be presented to the view.
        Optionally it can also coordinate requests to the Backend for that view
      - Flow Controllers
        
        Flow Controllers
        Dedicated object that coordinates interactions between Views that belong to the same flow
        E.g, SignInFlow: Welcome View > Sign Up View > Onboading View
        
        MVC / MVVM
        Each View can choose to implement the MVC or MVVM patterns based on the complexity of that View
      - Clean / VIPER / MVC-N / Flux
      - In iOS there exist many types Architecture, but they all try to do the same thing, to give you a way to organise the app Responsibilities (see Native > Responsibilities) in a way that makes sense for a given project.
        They all have pros & cons, the most important thing is that once one of them is chosen, use the principles consistently throughout the project.
      - File Structure
      - SwiftUI
    - - Error Recovery
      - Push Notification
      - Analytics
      - Network Requests
      - Appearances
      - Unit / UI Testing