Software System Design Quiz 2

Status Codes in RESTful APIs

2xx: Success (e.g., 200 OK, 201 Created) - Indicates successful requests. 3xx: Redirection (e.g., 301 Moved Permanently, 304 Not Modified) - Requires the client to take additional action to complete the request. 4xx: Client Errors (e.g., 400 Bad Request, 404 Not Found) - Signifies errors from the client side. 5xx: Server Errors (e.g., 500 Internal Server Error) - Represents errors from the server side.

Map reduce (big data)

A paradigm tailored for distributed data processing Map: Processes chunks of data, producing key-value pairs Reduce: Aggregates these pairs to derive meaningful results Designed for handling vast datasets efficiently across distributed systems

API Gateway

API Gateway acts as a reverse proxy to accept all API calls, aggregate the various services required to fulfill them, and return the appropriate result. Single Entry Point: Provides a unified API entry point, enabling the routing of requests to the appropriate downstream services. Request Management: Can manage and handle various tasks like request routing, composition, rate limiting, security (like API key validations), analytics, and monitoring. Microservices Architecture: Especially beneficial in a microservices architecture where it can route requests to the appropriate microservices.

API Gateway vs Load Balancer

API Gateway: Acts as a reverse proxy for API calls, providing a single entry point, request management capabilities, and routing to downstream services. Load Balancer: Distributes incoming network traffic across multiple servers to ensure high availability and scalability. An API gateway can contain a load balancer

Definition of apis

API is a set of rules that defines interactions between software applications, allowing them to communicate and share functionalities.

importance of database scaling

Accommodates Growth: Ensures the database can handle increased data volume and user interactions Maintains Performance: Sustains swift and reliable data retrieval and interaction, essential for user experience. Upholds Data Integrity: Preserves the accuracy and consistency of data under high demand, preventing data anomalies.

Horizontal Scaling

Adding more units to the system architecture Example: Adding new servers to a database cluster Cons: Increased system complexity, data consistency is challenging

Horizontal Scaling (API)

Advantages: Can handle more load by simply adding more servers. Failure in one server doesn't affect the others. Disadvantages: Requires more sophisticated setup and management, like load balancing. Ensuring data consistency across multiple servers can be challenging.

Vertical Scaling (API)

Advantages: Easier to implement as it doesn't require changes to the application, Can provide immediate performance boost. Disadvantages: There's a maximum limit to how much you can scale up. Often requires downtime to upgrade the hardware.

Recognizing the need for database scaling

Assess Database Performance: Regularly monitor database response times and query execution speeds. Analyze Data Growth Trends: Scrutinize the increments in data volume and the complexity of data interactions. Scale Proactively: Implement scaling solutions ahead of reaching database capacity to avoid performance degradation.

AutoScaling and API Scalability

AutoScaling optimizes server instances based on load, increasing API adaptability and efficiency. Adaptive Management: Adjusts resources in real-time for optimal utilization. High Availability: Ensures service is available during demand spikes by allocating necessary resources. Cost-Efficient: Reduces costs by allocating resources only when needed, avoiding over-provisioning.

Backup vs replication

Backup: Provides a static, recoverable copy of the data to protect against data loss and corruption. Replication: Creates dynamic, real-time or near-real-time copies of data to enhance availability and load balancing. Distinct Purposes: While replication increases availability, it does not replace the need for a dedicated backup strategy.

Load balancer placement

Between the User and Web Server: It can distribute incoming network traffic across multiple web servers. Between Web Server and an Internal Platform Layer: It can handle traffic between different service layers within the architecture. Between Internal Platform Layer and Database: It can balance loads and manage requests coming to the database.

Caching and API scaling

Caching, by storing and serving frequent read requests, significantly reduces the load on the server and database, contributing to efficient API scaling. Reduced Load: Serving cached responses reduces the number of requests to the server, minimizing resource utilization. Enhanced Response Times: Cached responses are typically faster, improving user experience and service efficiency. Lowered Database Stress: By serving cached data, the number of read requests to the database is decreased, preventing potential bottlenecks.

data warehouses (big data)

Central repositories optimized for analytics and reporting Data is cleaned, transformed, and structured for performance

How RPC works

Client-Server Model: The client sends a request to the server, and the server returns a response. Stub Procedures: Simplify the communication process by abstracting network details. Interface Definition Language (IDL): Defines the available procedures and data types.

columnar stores vs row oriented model

Columnar databases excel at analytical queries on specific columns They offer storage optimizations through column-wise compression Row-oriented databases are more suited for transactional systems Write operations are generally more efficient in row-oriented databases

columnar stores

Columnar stores organize data by columns rather than rows Designed for efficient read operations, especially for analytics Compression techniques optimize storage and enhance query performance Not optimized for frequent write or update operations

RPC vs REST

Communication: RPC is procedure-oriented and invokes specific functions, while REST is resource-based and manipulates resources using HTTP methods. Statelessness: REST is stateless, with each request containing all necessary information, while RPC can maintain state between requests. Coupling: RPC often results in tighter coupling due to the necessity to know the available procedures, while REST offers looser coupling.

CDN and API scaling

Content Delivery Networks (CDN) enhance API scalability by distributing the load, serving static content closer to the user, and reducing latency. Distributed Load: CDNs help in distributing the load by serving content from the nearest location to the user, reducing stress on the origin server. Reduced Latency: By serving content closer to the users, CDNs significantly reduce the latency, improving user experience. Enhanced Reliability: CDNs provide redundancy, enhancing reliability and availability even during high traffic or failures.

GraphQL vs RESTful APIs

Data Retrieval: GraphQL allows clients to request exactly the data they need, while REST retrieves all data associated with the resource. Number of Requests: GraphQL can retrieve all needed data in a single request, while REST may require multiple requests to different endpoints. Schema and Type System: GraphQL uses a strong type system and defines the capabilities of the API using a schema, ensuring more reliable interactions.

RPC vs GraphQL

Data Retrieval: GraphQL allows clients to specify the data structure, while RPC invokes specific procedures. Flexibility: GraphQL offers more flexibility in fetching data, while RPC is more rigid and procedure-oriented. Coupling: RPC tends to have tighter coupling due to the need to know available procedures, while GraphQL has looser coupling.

Relational Data Model

Data is organized into tables, each record (data entry) is represented as a row in a table, table columns define the specific properties that each record can have

Database caching

Database caching involves storing copies of files or data results in strategic locations to improve access times and reduce load on the main database. Enhances Performance: Enables faster data retrieval and reduces the need to query the main database repeatedly. Reduces Database Load: Offloads the main database by serving the majority of read requests, prolonging its lifespan and efficiency.

Database partitioning

Database partitioning segments a table into smaller, more manageable pieces, yet all pieces remain part of the same logical table. Improves Performance: Enables efficient management and faster queries. Internal Management: Occurs within the same database system, optimizing internal structure.

Database Replication

Database replication is a method of copying data to maintain synchronized multiple copies across different nodes or servers. Enhances Data Availability: Provides continuous data availability, reducing downtime. Facilitates Load Balancing: Distributes read and write operations among multiple nodes to optimize performance. Serves as a Backup: Acts as a safeguard to recover data in case of node failures.

Replication Patterns

Database replication patterns synchronize and maintain consistent data copies across multiple nodes to enhance availability and read scalability. Single Primary: One node (primary) handles writes; replicas are read-only. Guarantees strong data consistency but can limit write scalability due to potential write bottlenecks. Multi Primary: All nodes can independently handle writes and reads. Improves write scalability but requires sophisticated conflict-resolution mechanisms to maintain data consistency.

Database sharding

Database sharding involves segregating a large dataset into smaller, manageable parts, called shards, and distributing them across multiple databases or nodes. Enhances Performance: Enables faster queries and parallel processing by reducing the database size. Scales Systems: Ideal for large-scale systems with extensive data requirements.

object storage vs database

Databases excel at structured data and complex queries Object storage focuses on storing vast amounts of unstructured data Data is stored as objects with unique identifiers and metadata Scales horizontally and is optimized for retrieval and storage rather than complex querying

When designing RPC APIS

Define Clear Procedures: Clearly define the available procedures and their inputs and outputs using an Interface Definition Language (IDL). Minimize Coupling: Avoid overly complex procedure definitions and try to minimize the dependency between the client and the server. Error Handling: Define clear error messages and handle errors gracefully to aid in debugging and resolution.

Partitioning APIs

Definition: Dividing the server's duties and responsibilities, often by the type of request or data being handled. Purpose: To allow each partition to operate independently, improving efficiency, and making the system more manageable and scalable. Application in APIs: Different API routes or endpoints can be handled by different servers, each optimized for a specific set of tasks or data.

Why database selection matters

Direct influence on overall system performance Vital for system scalability as data grows Ensures long-term system maintainability Crucial for maintaining data integrity and consistency

Load Balancing (API scaling)

Distributes incoming network traffic uniformly across multiple servers. Prevents any one server from getting overwhelmed and optimizes resource use. Enhances application responsiveness and availability.

Which database for variety

Diverse data types: NoSQL's flexible schema is beneficial Structured data with well-defined relationships: Relational databases are apt

document stores vs relational model

Document stores offer flexible schemas; relational databases require predefined schemas While relational databases use table joins, document stores can embed data Document stores scale horizontally, adding more machines for more data Choice often boils down to application needs and data access patterns

Document stores (type of non relational database)

Document stores save data in document-like structures, typically JSON They allow flexible schemas, adapting to varied data needs Documents can have embedded arrays or documents, providing depth They're particularly suitable for hierarchical data structures.

Vertical Scaling

Enhancing the capacity of individual resources (e.g., the database server) Example: Upgrading server RAM or CPU Cons: Limited by hardware capability, potential single point of failure

Types of database backup

Full Backup: Copies all the data in the entire database. Provides the most comprehensive coverage but requires more storage and time. Incremental Backup: Only backs up the data that has changed since the last backup. Faster and requires less storage but relies on a chain of previous backups for full recovery. Differential Backup: Backs up all the data that has changed since the last full backup. Striking a balance between full and incremental backups.

graph stores vs relational model

Graph databases excel in representing relationships; relational databases rely on joins They allow efficient traversal of multiple levels of relationships Suited for complex relationship queries, which might be cumbersome in relational models However, for tabular data with minimal relationships, relational databases might be more apt

graph stores

Graph databases store data in nodes (entities) and edges (relationships) Suited for highly connected data like social networks, recommendation engines, and complex relational data Queries can traverse multiple nodes and relationships, fetching complex patterns

GraphQL

GraphQL is a query language for APIs and a runtime for executing those queries. Developed by Facebook: To address the needs for more efficient and powerful data fetching in modern applications. Declarative Data Fetching: Clients specify what data they need, avoiding over-fetching or under-fetching of data. Single Endpoint: All requests are directed to a single endpoint, improving maintainability and organization of API interactions.

When to consider load balancing

High Availability is Critical: When uninterrupted service is paramount. Handling High Traffic: When the system needs to efficiently manage a large number of requests. Optimizing Resource Use: When aiming to use server resources efficiently and prevent overloads. Scaling Horizontally: When adding more servers to enhance system capacity and performance.

Why consider database replication

High Data Availability Required: When the priority is to have continuous access to data. Read-Heavy Workloads: When the system predominantly handles read operations. Distributed Workload: When there is a need to balance loads among several nodes. Backup Mechanism Needed: When having a robust recovery system is crucial to mitigate the risks of node failures.

Which database for velocity

High-speed data operations: NoSQL databases might offer better performance Stable, transaction-oriented systems: Relational databases are reliable

Types of partitioning

Horizontal Partitioning: Divides rows into smaller tables with identical columns. Optimizes performance via parallel processing but challenges data consistency across nodes. Vertical Partitioning: Segments columns, creating smaller tables with identical rows. Streamlines data retrieval but necessitates meticulous data consistency management.

purpose of apis

Integration: Facilitates communication between various software entities, enabling seamless interaction and data sharing. Automation: Supports task automation, allowing systems to interact programmatically without human intervention. Efficiency: Optimizes data transfer by enabling extraction of specific data between applications.

Query optimizaiton

Involves constructing efficient queries to reduce database load Detailed analysis and refinement of queries yield significant performance improvements Effective optimization leverages database features and avoids unnecessary, resource-intensive operations

Server Replication (API scaling)

Involves creating identical copies of the original server. Helps in distributing the load and provides redundancy. Ensures continuous service availability in case of server failure.

key-value stores

Key-Value stores are simple database systems that use a dictionary-like structure Data is stored as a set of unique keys, each associated with a specific value They're optimized for rapid data retrieval using the key Suited for use cases where data access patterns are predictable Modern key-value stores were developed in response to the need for speed and scalability.

key value stores vs relational model

Key-Value stores are typically schema-less; data can vary without predefined structures They focus on rapid retrieval based on the key, often at the expense of complex querying Horizontal scaling allows them to handle massive amounts of data Relational databases, while versatile, may struggle with the scale and speed demands that key-value stores excel in

Types of sharding (types)

Key-based: Uses a specific key value, like user_id, for data distribution. Straightforward but can lead to unbalanced servers. Range-based: Allocates data based on ranges of a key's value, such as dates. Ideal for sequential data but prone to hotspots. Directory-based: Employs a lookup service to direct queries to the right shard. Offers flexibility but adds complexity.

Common caching strategies

LRU (last recently used), FIFO (first in first out), LFU (least frequently used)

Which databases for volume

Large datasets: NoSQL databases can offer better scalability (ie big data applications) Moderate datasets with well-defined relationships: Relational databases excel

Load Shedding

Load Shedding is a technique to prevent system overload by intentionally dropping incoming requests when the server is under heavy load. It maintains system stability, protects critical resources, and enhances service resilience

Load balancing

Load balancing is the process of distributing network or application traffic across multiple servers to ensure no single server bears too much demand. Enhances Performance: By efficiently allocating requests, it prevents any single server from becoming a bottleneck. Increases Reliability and Availability: It ensures uninterrupted service by redistributing loads in case of server failure.

Microservices

Microservices Architecture involves developing a single application as a suite of small services, each running in its own process and communicating through APIs. Independently Deployable: Each service is independently deployable, allowing for easier updates and maintenance. Single Responsibility: Every service is designed to perform a specific business function and has a single responsibility. Decoupled Services: Services are loosely coupled, enabling them to be developed, deployed, and scaled independently.

Microservices and scalability

Microservices architecture significantly aids in building scalable and resilient systems by allowing individual components to scale independently based on their resource requirements and usage patterns. Independent Scaling: Each service can be scaled independently, allowing for more efficient resource utilization and handling of varied loads. Enhanced Fault Isolation: Failure in one service doesn't directly impact others, improving system resilience. Complexity Management: Microservices can introduce complexity in terms of service interactions, deployment, and monitoring, necessitating effective management strategies.

Impact & Importance of APIs

Modularity: Promotes development of clear, independent, and manageable software components, enhancing maintainability. Innovation: Fosters creation of new business models and extension of services, by allowing integration and building upon existing services. Scalability & Performance: Facilitates efficient scalability of individual components, ensuring high performance and availability.

Database selection CAP for consistency and availability

Prioritize Consistency: Typically served by relational databases (ACID properties) (best for finance systems, banking transactions, healthcare, e-commerce inventory) Prioritize Availability: Typically served by non-relational databases (Eventual consistency). (good for social media platforms, streaming services, e-commerce product recommendations)

When to use RPC

Procedure-Oriented Applications: When the interaction is more about invoking functions or procedures rather than manipulating resources. Strict Contract: When a strict contract between client and server is beneficial, as the client needs to know the available procedures. Efficiency & Performance: When the overhead of HTTP is undesirable and alternative transport protocols can optimize performance. Network Constraints: In environments with network constraints where a lightweight protocol is essential.

Database optimization strategies

Proper indexing, normalization/denormalization, query optimization

Schema pro vs con

Pros: If you're working with data of homogeneous structure, a fixed schema will help you ensure the data is valid. Cons: When the characteristics of the data vary too much, fitting the data to a fixed schema can be troublesome.

SOAP API

Protocol, not Architecture: It is a protocol rather than an architectural style like REST. XML-Based: It utilizes XML for message format, relying on other application layer protocols, primarily HTTP and SMTP, for message negotiation and transmission. Strict Standards and Specifications: It operates on strict standards and specifications, defining an extensive set of rules for structuring messages.

Database backup

Purpose: To create secure, static, point-in-time copies of data. Objective: To allow recovery to a known good state in case of data loss, corruption, or other disasters. Necessity: Backups are crucial as they safeguard data integrity and availability, preventing irreversible data loss.

RESTful API

REST stands for Representational State Transfer. It is an architectural style for designing networked applications. RESTful APIs use HTTP requests to perform CRUD operations on resources. RESTful APIs are by far the most common type of Web APIs.

Conclusion on REST/GraphQL/RPC APIs

RESTful APIs: Stateful, scalable interactions using standard HTTP methods, URIs, and status codes, focusing on web resources. GraphQL APIs: Flexible, efficient data interactions, allowing precise data retrieval, relying on a strongly typed schema, considering domain, performance, and security in design. RPC-based APIs: Intuitive for non-CRUD actions, leading to tighter coupling, with modern iterations like tRPC offering enhanced type safety, and the choice among them aligns with project needs and context.

When to consider database caching

Rapid Data Retrieval is Essential: To significantly improve data access times compared to querying the main database. Minimizing Database Load is Crucial: To maintain optimal performance and longevity of the main database by reducing the number of queries made to it. Operational Cost Efficiency is a Goal: When optimizing database operations to reduce resource usage and operational costs is essential.

Rate Limiting (API scaling)

Rate Limiting is a strategy to control the amount of incoming requests to a server, enabling the server to handle each request with optimal efficiency. Used to: Control traffic, maintain service availability, resource optimization

What are relational databases good for?

Relational databases make it easy to avoid duplicate information and data inconsistencies

relational vs non-relational databases

Relational databases: Structured schema, SQL-based, ACID properties Non-Relational databases: Flexible schema, variety (document, key-value, graph)

Remote Procedure Call (RPC)

Remote Procedure Call (RPC) is a protocol that one program can use to request a service from a program located on another computer in a network. Procedure-Oriented: Allows calling functions on a remote server. Synchronous Communication: Waits for the server to complete the task before resuming. Tight Coupling: Requires knowledge of the available procedures on the server.

Types of load balancing

Round Robin: Cyclically assigns requests to a list of servers. Simple but may not consider server load. Least Connections: Directs traffic to the server with the fewest active connections. Considers server load but may not account for request complexity. IP Hash: Assigns a specific IP range to each server. Ensures a user IP consistently reaches the same server but might lead to server overload.

Other types of web APIs

SOAP (Simple Object Access Protocol): A protocol that uses XML for message formatting in communication over the network. OData (Open Data Protocol): A protocol that allows the creation and consumption of queryable and interoperable RESTful APIs. JSON-RPC and XML-RPC: Remote procedure call (RPC) protocols encoded in JSON or XML respectively.

Scaling SQL vs NoSQL Databases

SQL Databases: Typically employ vertical scaling: adding more power to existing hardware to handle more load. NoSQL Databases: Known for horizontal scaling: adding more machines to handle larger loads. But all the scaling strategies discussed in this lecture are generally applicable to both SQL and NoSQL Databases.

Key concepts of GraphQL

Schema: Defines types, queries, and mutations, acting as a contract between client and server. Resolvers: Functions that determine how data for a specific field is fetched and returned to the client. Querying: Allows clients to specify needed data, reducing over or under-fetched data. Mutations: Operations that create, modify, or delete data, defined specifically in the schema.

Other database selection factors

Security: Ensuring data privacy and protection against threats Cost: Initial setup, scaling, maintenance, and licensing fees Community: Availability of support, tutorials, and a robust developer community Ecosystem: Integration capabilities with other tools, platforms, and systems

Horizontal Scaling Strategies (API)

Server Replication: Creating copies of the original server to distribute the load. Load Balancing: Distributing incoming network traffic across multiple servers. Partitioning: Dividing the server's duties and responsibilities, often by the type of request or data being handled. API Gateway: Managing and handling API requests, acting as a reverse proxy to forward requests to the appropriate service. Microservices Architecture: Decomposing the API into smaller, independent services that can be scaled individually.

Types of sharding (def)

Sharding types dictate how data is distributed across nodes, affecting system balance and complexity.

When to consider database sharding

Single Server Limitations: When the dataset is too large to be handled by a single server. Horizontal Scaling is Essential: When adding more machines to distribute the load is crucial for system performance. Geographical Data Proximity is Crucial: When reducing latency by positioning data closer to users is essential. Parallel Processing is Essential: When distributing data for simultaneous processing is crucial.

When to use SOAP

Stateful Operations are Needed: For operations where the client and server need to understand previous interactions and each other's states.Reliability and Security are Critical: In enterprise solutions, financial services, and telecommunication services where data integrity and confidentiality are paramount. ACID Compliance is Required: When transactions require Atomicity, Consistency, Isolation, and Durability, especially in database interactions. Interoperability is Essential: In environments where the API needs to interact with various platforms and languages, due to its strict standards and specifications. Stateful Operations are Needed: For operations where the client and server need to understand previous interactions and each other's states.

Principles of RESTful API design

Statelessness: Each request contains all information needed by the server. Client-Server Architecture: Client manages UI/UX; server manages resources, operating independently. Uniform Interface: Ensures consistent and standardized interactions. Cacheable: Responses can be marked as cacheable to improve performance. Layered System: Enables scalability through unknown intermediary servers.

When to consider database partitioning

Table Size Affects Performance: When a single table is too large, leading to performance degradation within a single server. Frequent Queries on Recent Data: When a table contains substantial historical data that is seldom accessed, but recent data is queried regularly. Optimizing Node Efficiency: Aiming to enhance the performance and manageability of each database node. Seeking Logical Data Segmentation: When data should be internally segmented yet part of the same logical entity.

N+1 query problem

The N+1 problem occurs when you make one query to fetch the main records and N additional queries to retrieve related data for each main record. (solved by optimizing your query, eg using joins)

Load Management strategies (API)

These strategies are usually implemented within an API Gateway. Rate Limiting: Restricting the number of requests a user can make in a given time frame to prevent abuse and ensure availability for all users. Throttling: Adjusting the speed at which a user can make requests, often used to allocate resources fairly among all users during high traffic. Load Shedding: Dropping requests when the server is overwhelmed, allowing it to maintain service availability during spikes in traffic.

Throttling

Throttling is a technique used to control the amount of incoming requests to a server by delaying the handling of the requests. Regulate Request Processing: Helps in managing the server's load by delaying the processing of some incoming requests. Prevent Server Overload: By slowing down the request processing, it ensures that the server does not become overwhelmed with too many requests at once. Enhance System Stability: Helps in maintaining the stability and reliability of the system by avoiding resource exhaustion. Implementation Approach: Often implemented by setting a delay in processing requests, and typically configured in the API Gateway.

Transactional (OLTP) vs analytical (OLAP)

Transactional (OLTP): Typically served by relational databases optimized for high transaction rates and real-time data processing. E.g., Financial transaction systems. Analytical (OLAP): Often suited for non-relational databases designed for complex queries and deep data analysis. E.g., Systems analyzing user behavior patterns.

When to use GraphQL vs REST

Use GraphQL when: Diverse, nested, and complex data requirements exist. The frontend team needs flexibility in data retrieval. Use REST when: The API has simple, flat, and static data structures. A standard, cacheable, and stateless API is suitable.

Service communication in microservices

Varied Mechanisms: Services use HTTP/REST, gRPC, GraphQL, and more, to interact effectively. Asynchronous Messaging: Message brokers and event streams enable decoupled, scalable, asynchronous inter-service communication. Protocol & Format Selection: Choosing the right communication protocol and data format is vital, affecting performance and interoperability.

data lakes (big data)

Vast repositories storing data in its raw form Accepts structured, semi-structured, or unstructured data Often built atop scalable solutions like object storage

Database scaling strategies

Vertical Scaling, Horizontal Scaling (replication, sharding, partitioning), caching

Scaling APIs strategies

Vertical Scaling: Increasing the capacity of a single server (e.g., adding more CPU, RAM). Horizontal Scaling: Distributing the load across multiple servers, often involving load balancing, replication, and partitioning. Load Management (Caching, rate limiting, throttling, and load shedding): Not strictly a scaling strategy but help maintain service availability during high load.

3Vs of data

Volume: Refers to the size or amount of data to handle Velocity: Deals with the speed of data processing and generation Variety: Captures the diverse types and sources of data

Web APIs

Web APIs allow different software systems to communicate with each other over the web using HTTP/HTTPS. Open APIs: Accessible to developers and the public (e.g., Twitter API). Internal APIs: Used within a company for internal services. Composite APIs: Access multiple endpoints in one call; useful for microservices. Partner APIs: Exposed to specific partners or collaborators.

Types of APIs

Web APIs: Enable communication over the web using HTTP/HTTPS. Library-based APIs: Packaged as libraries or SDKs, providing routines and tools for software development. Operating System APIs: Allow interaction with underlying OS services, enabling tasks like file handling and memory allocation. Database APIs: Enable communication between applications and database management systems, allowing CRUD operations on database records.

Types of RPC

gRPC: Developed by Google, uses HTTP/2 for transport, Protocol Buffers as the interface description language, and it is language-agnostic. tRPC: A type-safe RPC framework, often used with TypeScript, enabling type-safe API contracts between the client and the server.

Why did non relational databases emerge?

while versatile, relational databases can have limitations in scalability and handling unstructured data