• Customers with columns customer_id and name
• Products with columns product_id and name

SELECT customers.customer_id, customers.name, products.product_id, products.name
FROM customers
CROSS JOIN products;

var str = "P001.M003.PO888393"; 
var res = str.replace(/^[^\.]*\./, '');
console.log(res);

#=> M003.PO888393

docker push NAME[:TAG]

• Version control: Tags help identify different versions of an image.
• Traceability: Tags allow you to track changes and updates to an image.
  Automation: Tags are used in automated processes, such as deploying new versions.
  Troubleshooting: Tags help pinpoint specific image versions when debugging.
  Managing large-scale projects: Tags organize images in complex projects.
  
  

docker tag [OPTIONS] IMAGE[:TAG] [REGISTRYHOST/][USERNAME/]NAME[:TAG]

docker tag 518a41981a6a myRegistry.com/myImage

The PUT method requests that the enclosed entity be stored under the supplied Request-URI. If the Request-URI refers to an already existing resource, the enclosed entity SHOULD be considered as a modified version of the one residing on the origin server. If the Request-URI does not point to an existing resource, and that URI is capable of being defined as a new resource by the requesting user agent, the origin server can create the resource with that URI.

If a new resource is created, the origin server MUST inform the user agent via the 201 (Created) response. If an existing resource is modified, either the 200 (OK) or 204 (No Content) response codes SHOULD be sent to indicate successful completion of the request. If the resource could not be created or modified with the Request-URI, an appropriate error response SHOULD be given that reflects the nature of the problem.

// Add a request interceptor
axios.interceptors.request.use(function (config) {
    // Do something before request is sent
    return config;
  }, function (error) {
    // Do something with request error
    return Promise.reject(error);
  });

// Add a response interceptor
axios.interceptors.response.use(function (response) {
    // Any status code that lie within the range of 2xx cause this function to trigger
    // Do something with response data
    return response;
  }, function (error) {
    // Any status codes that falls outside the range of 2xx cause this function to trigger
    // Do something with response error
    return Promise.reject(error);
  });

'use client'

import { usePathname } from 'next/navigation' 

export default function ExampleClientComponent() {  
  const pathname = usePathname()  
  
  return <p>Current pathname: {pathname}</p>
}

<Link 
  key={link.name}
  href={link.href}            
  className={clsx(              
     'flex h-[48px] grow items-center justify-center gap-2 rounded-md bg-gray-50 p-3 text-sm font-medium hover:bg-sky-100 hover:text-blue-600 md:flex-none md:justify-start md:p-2 md:px-3',
    {               
      'bg-sky-100 text-blue-600': pathname === link.href,
     },            
    )}         
   >            
   <LinkIcon className="w-6" />            
     <p className="hidden md:block">{link.name}</p>          
</Link>

• Idempotency is a property of operations or API requests that ensures repeating the operation multiple times produces the same result as executing it once.
• Safe methods are idempotent but not all idempotent methods are safe.
• 
  
• HTTP methods like GET, HEAD, PUT, DELETE, OPTIONS, and TRACE are idempotent, while POST and PATCH are generally non-idempotent.

function exampleFunction() {
    const value = 42;
    debugger; // Execution will pause here if a debugger is attached
    console.log(value);
}

exampleFunction();

node --inspect --5120 lib/app.js

Debugger listening on ws://127.0.0.1:9229/65b96f6d-6202-49db-bbe8-63b706a580a2

Visit the port on your browser and open the Node DevTools.

x = 10
y = x
print(id(x))  # Output: 140737469306640
print(id(y))  # Output: 140737469306640

del x
print(id(y))  # Output: 140737469306640

• Separation of concerns: Headless applications have a clear separation between the frontend and backend, while frontend applications have a more integrated approach.
• Flexibility: Headless applications are more flexible as they can support multiple frontends and can be updated independently.
• Scalability: Headless applications can be scaled more easily as the frontend and backend can be scaled independently.
• Development: Headless applications often require more complex development processes due to the separation of concerns.
• User experience: Frontend applications typically provide a more cohesive user experience as the frontend and backend are tightly integrated.

• Frontend Application: This is a broad term that encompasses any application that interacts directly with the user. It could be a website, mobile app, or desktop application.  
• Headless Application: This is a specific architecture where the frontend (user interface) is decoupled from the backend (server-side logic) and communicates through APIs.   

1. Separates frontend and backend: The React app (frontend) is distinct from the backend service providing the API.
2. Uses APIs: The React app communicates with the backend through APIs to retrieve and manipulate data.  

• Decoupled front-end and back-end: The front-end and back-end components are separate entities that communicate through APIs.
• API-driven: The back-end provides APIs that the front-end can use to fetch data and perform actions.
• Multiple front-ends: A headless application can support multiple front-ends, such as web, mobile, and desktop applications.
• Flexibility: This architecture allows for rapid changes to the front-end without affecting the back-end, and vice versa.
• Scalability: The front-end and back-end can be scaled independently to meet changing demands.

• Faster development: The decoupled architecture allows for parallel development of the front-end and back-end.
• Improved flexibility: The ability to update the front-end without affecting the back-end enables rapid changes and experimentation.
• Enhanced scalability: The ability to scale the front-end and back-end independently ensures optimal performance and resource utilization.
• Reusability: The back-end can be reused for multiple front-ends, reducing development effort.
• Improved user experience: Headless applications can provide a more consistent and responsive user experience across different platforms.

• Unified interface: It presents a consistent API to clients, regardless of the backend services being accessed.
• Authentication and authorization: It can handle authentication and authorization, ensuring that only authorized users can access specific resources.
• Rate limiting: It can implement rate limiting to prevent abuse and protect backend services from overload.
• Caching: It can cache frequently accessed data to improve performance and reduce load on backend services.
• Transformation: It can transform data between different formats, ensuring compatibility between clients and backend services.
• Security: It can provide security features like encryption, data validation, and protection against common attacks.

• Simplified development: It reduces the complexity of client-side development by providing a single endpoint.
• Improved performance: It can improve performance by caching data and optimizing communication with backend services.
• Enhanced security: It can strengthen security by implementing authentication, authorization, and rate limiting.
• Scalability: It can handle increased traffic by distributing load across multiple backend services.
• Flexibility: It can adapt to changes in backend services without affecting clients.

• Traffic distribution: It directs incoming traffic to the most appropriate server based on various factors, such as server load, health status, and application requirements.
• Failover: If a server fails or becomes unresponsive, the load balancer can automatically redirect traffic to a working server, ensuring uninterrupted service.
• Session persistence: It can maintain session affinity, ensuring that requests from a particular client are always routed to the same server, preserving the state of the session.
• Performance optimization: Load balancers can improve performance by reducing latency, increasing throughput, and enhancing overall system responsiveness.
• Security: Some load balancers can provide security features like SSL termination, DDoS protection, and access control.