menu
This method is used to replace the first occurrence of a specified pattern. 

Example:

text = "Hello, World! This is a test. Hello, Universe!" 
new_text =text.sub("Hello", "Hi") 
puts new_text # => "Hi, World! This is a test. Hello, Universe!" 

This method is used to retrieve a list of all the public methods available for an object. This method returns an array of symbols, where each symbol represents a method that can be called on the object.

This method can be used to know the class of an object, which allows you to inspect and work with the class itself, rather than just the object. 

Example:

"Hello".class # => String 
10.class # => Number 
10.0.class # => Float 

The "readonly" modifier is used to indicate that a property or variable should not be modified once it has been initialized. It ensures that the value of the property remains constant throughout the lifetime of the object or variable.
 
Example with an array:

const numbers: readonly number[] = [1, 2, 3]; 
numbers[0] = 4; // Error! Cannot assign to an element of a readonly array 
numbers.push(4); // Error! Cannot push to a readonly array 

This method is the opposite of the .blank? method. It is used to check whether a string, array, or other data structure contains meaningful content, and it returns true if the object is not empty, contains non-whitespace characters, or is not nil. Otherwise, it returns false.

Example:

"".present? # false (empty string) 
" ".present? # false (whitespace characters only) 
nil.present? # false (nil) 
"hello".present? # true (contains non-whitespace characters) 
[1, 2, 3].present? # true (array with elements) 

This method is used to check whether a string, array, or other data structure is empty or contains only whitespace characters.
 It returns true if the object is empty contains only whitespace, or is nil. Otherwise, it returns false. 

Example:

"".blank? # true (empty string) 
" ".blank? # true (whitespace characters only) 
nil.blank? # true (nil) 
"hello".blank? # false (contains non-whitespace characters) 
[1, 2, 3].blank? # false (array with elements)

The "SELECT INTO" statement is used to retrieve data from a database table and store it into variables or a new table. 

Example:

-- Assigning Values to Variables 
DECLARE @variable_name data_type; 
SELECT column_name INTO @variable_name FROM table_name WHERE condition;-- Creating a New Table 
SELECT column1, column2 INTO new_table FROM old_table WHERE condition;-- Inserting Data into an Existing Table 
INSERT INTO existing_table (column1, column2) 
SELECT column1, column2 FROM source_table WHERE condition;

Javascript supports currency formatting without any library. 

Example:

const number = 123456.789;console.log(new Intl.NumberFormat('de-DE', { style: 'currency', currency: 'EUR' }).format(number)); 
// Expected output: "123.456,79 €"// The Japanese yen doesn't use a minor unit 
console.log(new Intl.NumberFormat('ja-JP', { style: 'currency', currency: 'JPY' }).format(number)); 
// Expected output: "¥123,457"// Limit to three significant digits 
console.log(new Intl.NumberFormat('en-IN', { maximumSignificantDigits: 3 }).format(number)); 
// Expected output: "1,23,000"

The first parameter used is an Intl namespace internationalization.
StricMode is a tool to help React developers detect possible issues in the code. 

Some advantages are: 

  1. Identify early problems
2. Detection of unwanted side effects
3. Improved code quality
API Gateway is like a traffic cop for web services and applications. It's a server that acts as a single entry point to manage, control, and route incoming and outgoing requests between various parts of a software system. 

Imagine a busy intersection with multiple roads and vehicles. The API Gateway sits at the center and directs traffic. Here's what it does: 

1. Routing: It decides where an incoming request should go based on the request's path, method, or other criteria. Just like a traffic cop directing vehicles to the right lanes.
2. Load Balancing: When there are multiple instances of a service running, the API Gateway can distribute incoming requests evenly among them to prevent overloading any single instance.
3. Authentication and Authorization: It can handle user authentication and ensure that only authorized users can access certain services. Think of it as checking IDs before letting someone into a restricted area.
4. Caching: To reduce load on services, the API Gateway can store responses from services and provide cached data when possible, like a vending machine having snacks readily available.
 
In essence, an API Gateway simplifies and centralizes how different parts of a software system communicate with each other and with external clients. It streamlines the flow of data and ensures that everything runs smoothly, just like a well-managed traffic intersection.
In JavaScript, console.time is a method that helps you measure the time it takes for a specific block of code to execute. It's like a stopwatch for your code. 

Example:

// Start the timer 
console.time('myTimer');// Simulate a time-consuming operation 
for (let i = 0; i < 1000000; i++) { 
 // Some code here 
}// Stop the timer and display the elapsed time in milliseconds 
console.timeEnd('myTimer');
 
So, when you run this code, you'll see something like: "myTimer: 23.789ms"
In PostgreSQL, the FOUND variable is a simple flag that helps you check if a query has found any results. It's like a "yes" or "no" indicator. 
 
1. When a query successfully finds one or more results, FOUND is set to true (or "yes").
2. When a query doesn't find any results, FOUND is set to false (or "no").

You can use FOUND in control structures like IF statements to make decisions based on whether your query found anything or not. It's a handy way to handle the outcome of a database search in your SQL scripts.
In PostgreSQL scripts, you can use global variables by defining custom variables and using them within your SQL code.
 
Example:

-- set a global variable 
SET my_var = 42;-- use the global variable 
SELECT * FROM my_table WHERE column = my_var;-- unset the global variable RESET my_var;

Complexity: Managing many small services can be like juggling a lot of balls. It can get complicated to coordinate and keep track of all these services. This complexity can make development and debugging more challenging.

Communication Overhead: In a microservices architecture, services often need to talk to each other over a network. This communication adds overhead and can slow things down compared to a monolithic system where everything is in one place.

Deployment Challenges: Deploying changes to multiple services can be like herding cats. Each service may have its own version, and coordinating updates across all of them can be tricky. It requires careful planning and automation.
Flexibility: Microservices allow you to independently build and update different application parts. It's like having building blocks that you can rearrange or replace without affecting the entire structure. This flexibility makes it easier to adapt to changing needs and technologies.

Scalability: Imagine you're running a restaurant, and each dish is prepared in its kitchen. If one dish becomes popular, you can add more kitchens just for that dish without changing the whole restaurant. Microservices work similarly, allowing you to scale specific application parts to handle more traffic or load.

Fault Isolation: In a large application, if one part breaks, it can sometimes bring down the entire thing. If one service has an issue with microservices, it's like a single light bulb going out in a string of lights. The rest of the lights (services) can keep shining. This helps with fault isolation and keeps your application more robust.