Terms Flashcards
Serialization
Serializationis the process of converting a data object—a combination of code and data represented within a region of data storage—into a series of bytes that saves the state of the object in an easily transmittable form. In this serialized form, the data can be delivered to another data store (such as anin-memory computing platform), application, or some other destination.
Abstraction
Abstraction is one of thekey conceptsof object-oriented programming (OOP) languages. Its main goal is to handle complexity by hiding unnecessary details from the user. That enables the user to implement more complex logic on top of the provided abstraction without understanding or even thinking about all the hidden complexity.
Granular
Granular - In computer science, granularity refers toa ratio of computation to communication– and also, in the classical sense, to the breaking down of larger holistic tasks into smaller, more finely delegated tasks
Base64
- encoding isthe process of putting a sequence of characters (letters, numbers, punctuation, and certain symbols) into a specialized format for efficient transmission or storage.
- Encode information
- Sending binary data over texted based protocol such as HTTP
- Ensures text doesn’t get corrupted during transfer
- Doesn’t conceal data
- e.g submit HTML form using base64
Polyfill
Polyfill - assists with creating code that is compatible with multiple browsers
Compile Time
code that is compiled into machine code to become an executable program
Run Time
compiled program that can be opened and run by user, when an application is running, this is called run time
Static Typing
Static typingmeans that the executable form of a program generated at compile time will vary depending upon the types of data values found in the program
Dynamic Typing
means that the generated code will always be the same irrespective of the type — any differences in execution will be determined at run time.
Tree Shaking
Tree Shaking - It can happen that we add code to our bundle that isn’t used anywhere in our application. This piece ofdead codecan be eliminated in order to reduce the size of thebundle, and prevent unnecessarily loading more data! The process of eliminatingdead code before adding it to ourbundle is calledtree-shaking
Scopes
Scopes are where you can talk about variables
- Lexical scope - show up in document specifically
- Relate to runtime
- Region of code
- This keyword
- this is a input parameter that refers to the left of the dot at calltime
- this is an input parameter between the parentheses (function invocation) that gets its name assigned and talks about the object to the left of the dot at callltime. So you don’t have to pass parameters
Heuristic Programming
employs a practical method, not guaranteed to be optimal, perfect, logical, or rational, but instead sufficient for reaching an immediate goal
SSH
SSH, also known as Secure Shell or Secure Socket Shell, is a network protocol that gives users, particularly system administrators, a secure way to access a computer over an unsecured network.
HTTP
- Protocol for communication between web servers and clients
- Every request is completely stateless (doesn’t remember the requests)
- HTTPS is Hyper text transfer protocol secure
- Data sent is encrypted (SSL / TLS)
Node
- comes with many APIs suitable for backened development e.g filesystems http requests, streams, child processes
- efficient with real time applications and facilitates multiple client requests, enables resharing and resuing packages of library code
How node works
- event-driven, server consists of one thread processing event one after another
- server doesn’t wait for process to complete but registers callback function
- server needs to create additional threads or switch between threads
- Single threaded event loop model
Authentication vs Authorization
- authentication is process of verifying identity of user by obtaining credentials and verifying user
- if credentials are valid, authorization process starts
- authentication -> authorization
- authorization is process of allowing authenticated users to access resources
Middleware
- refers to reusable components plugged into express application
- consists of functions that handle HTTP requests
- manipulates request and response objects and sends response to client or pass control to following middleware
- app.use() for express middleware
- calling next() moves onto next middleware or route
Stream
- sequence of data being moved from one point to another over time
- don’t need to wait for all data to be available before processing when huge amount of data to process
- big data is broken down and sent in chunks
JWT
- explicit, compact self contained secured protocol
- digitally signed and encrypted
- stateless, all information needed to complete a particular request is sent along with it including an Authorization HTTP header
- JWT are signed and contents are protected from tampering, can’t change contents without invalidating them
Long Polling
- Instead of resolving request immediately with result, have server hold onto request until server has data available
- Creates open connection with server
- Solves latency problem from polling
- Cons - Maintain open connection, still have to initiate new request to get new data from server
WebSocket
- Maintain open connection, duplex connection
- TCP protocol (16 bits for port number) limit of 65k connections per server
- Needs lots of server to handle multiple web socket connections
- Use load balancer to many requests
DOM
- document object model, an API for webpage allows program to read and manipulate page content structure and styles
- DOM is object-based representation of source HTML document
- converts structure/content of HTML document into object model used by various programs
- Represented by a node tree
Redis
Redis
- noSQL database
- alll data stored as key value pairs
- one giant JSON object
- not good at storing structured data
- good at storing individual key value pairs
- incredibly fast runs inside of working memory (RAM)
- more volatile , system crashes you lose everything in REDIS
- generally not used as persisent database
- used more for caching
- things that take longer to compute usually stored in REDIS
- built on top of traditional DB, sits in front traditional DB
- used for long, slow queries or data that is accessed frequentyl but doesn’t change
- store this information in redis and database and if it’s in redis, query will be much faster 100 to 1000 times faster
- redis stores values as string by default
Singleton JS Pattern
Singleton - Single global instance that is shared throughout application. Allows us to use a single instance across multiple files without having to reinstantiate it across multiple files.
Freeze the class/object so that the object is not modifiable
Pros: Potentially save lots of memory
Cons: ES2016 Modules are singletons by default
Proxy JS Pattern
Proxy - is used to intercept requests to a targeted object and decide whether or not to forward on those requests. Proxies make it easy to add functionality such as validation, logging, formatting, notifications, and debugging.
Pros: add functionality to a project, add validation
Cons: Methods run every time run-ing proxy object which can lead to performance issues
Observe Pattern
Observe Pattern - consists of an observable object and subscribers that will be notified by the observable object. This creates an efficient separation of concerns because the observable object has no knowledge of the subscribers. The subscribers are not aware of the underlying implementation that leads to the notification.
Factory Pattern
Factory Pattern - is a function that returns an object. The function may accept parameters and use those parameters to create more properties on the returned object. This pattern is useful when creating multiple objects that share the same set of properties.
Prototype Pattern
Prototype Pattern - which is more memory efficient than the factory pattern because it avoids the duplication of shared properties and methods by elevating them up the prototype chain. The prototype pattern can be used with the Object.create method or with ES6 classes.
Monolith Architecture
Monolith
- Misconception that monolith are huge machine that runs entire service
- Doens’t have to be single, might be multiple monolith service
PROS
- Good for small teams
- Less Complexity
- Less Duplication (less pipelines)
- Procedure calls are faster because calling same instance
CONS
- More context required for new members
- Complicated Deployments (monitored after every deployment and not decoupled)
- Much more responsibility on each server (single point of failure)
Microservices
- Misconception that micro service ne function running on one machine with tiny databases that are interconnected
- Clients are connected to different microservices
- Separate services based on concern of service
- Usually talk to own dedicated micro services
PROS - Easier to scale, only caring about its own data
- Easier to design
- Easy for onboarding new team, only understand context of feature they’re working on
- Working in parallel, can work on multiple features at one time
CONS - Needs skilled architect
- Might need to justify microservice architecture
Virtualization
Virtualization has its roots at the beginning of computer science when large, expensive mainframe computers were the norm. How could multiple programmers use the same single machine? The answer was virtualization and specifically virtual machines which are complete copies of a computer system from the operating system on up.
Docker
Docker is a way to isolate an entire operating system via Linux containers which are a type of virtualization
- Virtualization software that makes developing and deploying applications much easier
- Packages application with necessary dependencies, configuration, system tools and runtime
- Standardized unit that has everything the application needs to run
Virtual Machine vs Docker
- OS has 2 main layers (OS Kernel and OS Application Layer)
- OS Kernel is what communicates with hardware components (CPU, memory storage)
- Kernel is the core of every operation system and interacts between hardware and software components
- Docker virtualizes the applications layer
- It contains the OS application layer and services and apps installed on top of that layer (e.g Java runtime)
- Main difference is that VM virtualizes both Kernel and Applications layer
- When you download VM image on your host, it boots up its own Host
Difference between Docker and Virtual Machine
- Docker images are much smaller because it only implements one layer of OS
- Docker images are couple of MB , VM images are couple of GB
- Docker containers take seconds to start as it reuses the host kernel, VMs take minutes to start
- Virtual machines compatible with all OS, Docker is not compatible with Linux Distros
- Linux based Docker images cannot use Windows kernel
- Most containers are linux based, originally built for linux
- Docker Desktop allows you to run Linux containers on Mac and Windows
- Docker Desktop uses a hypervisor layer with lightweight linux distro
Encapsulation
Encapsulation is the mechanism of binding the data together and hiding it from the outside world. Encapsulation is achieved when each object keeps its state private so that other objects don’t have direct access to its state. Instead, they can access this state only through a set of public functions.
Abstraction
Abstraction: Abstraction can be thought of as the natural extension of encapsulation. It means hiding all but the relevant data about an object in order to reduce the complexity of the system. In a large system, objects talk to each other, which makes it difficult to maintain a large code base; abstraction helps by hiding internal implementation details of objects and only revealing operations that are relevant to other objects.
Inheritance
Inheritance: Inheritance is the mechanism of creating new classes from existing ones
Polymorphism
Polymorphism (from Greek, meaning “many forms”) is the ability of an object to take different forms and thus, depending upon the context, to respond to the same message in different ways. Take the example of a chess game; a chess piece can take many forms, like bishop, castle, or knight and all these pieces will respond differently to the ‘move’ message.