DEV Community: Salman Asu

important status code to be known as API developer

Salman Asu — Wed, 08 Jan 2025 16:26:34 +0000

success
200 ok

use with get method after receiving success response

201 created

use with post method when data is add or modify in database

client error
400 bad request

use when user send wrong data with payload, parameter or query

401 unauthorize

use when unauthorize user or without login user try to access the resources.

403 forbidden

use when user is authorize but not have permission to access the resources(admin).

404 page not found

use when user try to access invalid route.

server error
500 internal server error

when something went wrong with code or server.

*for more refer *

Load balancer vs Gateway vs reverse proxy vs forward proxy

Salman Asu — Sat, 28 Dec 2024 11:01:20 +0000

Today I will discuss about most use service in system design and difference between them.

load balancer distribute load to different server according to algorithim set in load balancer configuration.

Gateway have additional + load balancer.
it can process the request and send response + distribute load to different server according to alogrithim set in load balancer configuration.
above I have discuss about two scenario.

forward proxy is used to hide the user identity. it make a request to server on behave of client.

reverce proxy is used to hide the server identity. it make a response to client on behave of server.

simple request response using all the services in one system.

HTTP Headers in API

Salman Asu — Mon, 23 Dec 2024 07:58:59 +0000

http header are the field in http api request and response.

it is like setting up the address from and to in sending envelop to postman.

similarly http header are doing so.
*simple request header *

response header for same request

** some of build in header are **

host
path
content-type and many other refer doc

_u can add own custom header. _
like req.setHeader("X-myname","sallbro");
it is best practise to add X before name of header to identify it is custom header.

flow design for access and refresh token- JWT

Salman Asu — Thu, 19 Dec 2024 15:06:42 +0000

let build low-level-design for the same.

one’s the token is store on both side server and client. if now user try to access the pages authenticate the user with that token’s

first validate the access token, if the access token is expire than validate the refresh token to generate new access token and refresh token.

if refresh token is also expire than redirect the user to login route. after success credential generate new access token and refresh token and repeate the same cycle.

note: every time when we generate new token, we generate both new access token and refersh token.

@sallbro

comparing Domain-Driven Design (DDD) and Clean Architecture

Salman Asu — Tue, 03 Dec 2024 09:40:57 +0000

main difference between domain-driven design and clean architecture is we are seperating business login, infrastructure and presentation layer for individual module in domain-driven design(DDD).

where seperating business login, infrastructure and presentation layer onces for all module in clean architecture.

Here’s a simplified folder structure comparing Domain-Driven Design (DDD) and Clean Architecture, ensuring clarity and scalability while reducing unnecessary depth.

let take an example for creating folder structure for user and blog module...

Domain-Driven Design (DDD)

src/
├── modules/                    # Feature-based modules
│   ├── user/                   # User module
│   │   ├── application/        # Use cases (business logic)
│   │   │   ├── create-user.usecase.ts
│   │   │   └── update-user.usecase.ts
│   │   ├── domain/             # Core business logic
│   │   │   ├── user.entity.ts
│   │   │   ├── user.repository.ts
│   │   │   └── user.validator.ts
│   │   ├── infrastructure/     # Data access and persistence
│   │   │   ├── user.repository.impl.ts
│   │   │   └── prisma.service.ts
│   │   ├── interfaces/         # Controllers, APIs, and DTOs
│   │   │   ├── user.controller.ts
│   │   │   ├── create-user.dto.ts
│   │   │   └── update-user.dto.ts
│   │   └── user.module.ts      # Module setup
│   ├── blog/                   # Blog module
│   │   ├── application/
│   │   ├── domain/
│   │   ├── infrastructure/
│   │   ├── interfaces/
│   │   └── blog.module.ts
├── shared/                     # Shared utilities and services
│   ├── exceptions/
│   │   └── custom-error.ts
│   ├── utils/
│   │   └── logger.service.ts
├── main.ts                     # Entry point
└── app.module.ts               # Root application module

Clean Architecture

src/
├── core/                       # Core application logic
│   ├── usecases/               # Application use cases
│   │   ├── create-user.usecase.ts
│   │   ├── update-user.usecase.ts
│   │   ├── create-blog.usecase.ts
│   │   └── update-blog.usecase.ts
│   ├── entities/               # Domain models/entities
│   │   ├── user.entity.ts
│   │   ├── blog.entity.ts
│   │   └── index.ts
│   ├── repositories/           # Repository interfaces
│   │   ├── user.repository.ts
│   │   ├── blog.repository.ts
│   │   └── index.ts
│   └── validators/             # Domain-level validations
│       ├── user.validator.ts
│       ├── blog.validator.ts
│       └── index.ts
├── adapters/                   # Adapters for data and frameworks
│   ├── database/               # Database layer
│   │   ├── prisma/
│   │   │   ├── schema.prisma
│   │   │   ├── prisma.service.ts
│   │   │   └── user.repository.impl.ts
│   │   └── blog.repository.impl.ts
│   └── controllers/            # Controllers (API endpoints)
│       ├── user.controller.ts
│       ├── blog.controller.ts
│       └── index.ts
├── config/                     # Configuration files
│   └── app.config.ts
├── shared/                     # Shared utilities
│   ├── exceptions/
│   │   └── custom-error.ts
│   ├── utils/
│   │   └── logger.service.ts
│   └── index.ts
├── main.ts                     # Entry point
└── app.module.ts               # Root application module

Choose DDD if the application is domain-complex and feature-based, or Clean Architecture if you want to prioritize clear separation of layers. Let me know which one resonates!

want to know more about me, just write sallbro on search engine...

All About Typescript For Javascript Developer

Salman Asu — Fri, 22 Nov 2024 08:59:18 +0000

interface:
to define the structure or shape of an object and specify the properties and methods that an object has or should have.
interface is built-in feature of typescript.
use interface if it possible instead of types.
usecase type checking, easier debugging
we can use interface at different level at:

function type use interface to their argument or return value.
class in object constructor
Optional properties
readonly properties

types alias:
u can create a complex type by combining multiple type.
One major difference between type aliases vs interfaces, are that interfaces are open and type aliases are closed.
=>This means you can extend an interface by declaring it a second time.
e.g

interface Kitten {
  purrs: boolean;
}

interface Kitten {
  colour: string;
}

// In the other case a type cannot be changed outside of
// its declaration.

type Puppy = {
  color: string;
};

type Puppy = {
  toys: number;
};

=>we can event extent the type with intersection type (&)
e.g.

type UserEvent = PlayEvent & {UserId: string}

extend keyword can be use with interface or class

unions:
Union types in TypeScript allow us to define a variable or parameter that can hold values of multiple types.
Use pipe (|) symbol to combine two or more data types to achieve Union type.
e.g

const randomtype= string | number

For example, you can describe a boolean type as being either true or false:

type MyBool = true | false;

casting:
converting type into another type
e.g

let x: unknown = 'hello';
console.log((x as string).length);

generics:
defining varaible to type
e.g when value of type is unkown while creating or defining a function, but known after calling a function, we use generic

function myfun<type>(arg:type):type{
     return arg;
    }
    myfun<number>(3);

type inside a type, u can defined generics at array, map or set.
we can declare own type that use generics

duck or structure typing:
This technique is used to compare two objects are identical in terms of having matching properties and methods(Type-checking).
e.g

class Pigeon {
  sound = "coos";
}

class Owl {
  sound = "hoots";
}

class Penguin {
  sound = "peeps";
  swim() {
    console.log("I'm a bird and i can swim");
  }
}

let pigeon: Pigeon = new Owl();      // Works
let owl: Owl = new Pigeon();         // Works
let pigeon2: Pigeon = new Penguin(); // Works
let penguin: Penguin = new Pigeon(); // Compile time error

enums:
it is a way to defining set of constant in typescript, collection of related value of different data type.
usecases-
Enums provides a great way to organize the code in TypeScript.
Enums saves compile-time and runtime with inline code in JavaScript.

tuples:
In JavaScript, arrays consist of values of the same type, but sometimes we need to store a collection of values of different types in a single variable.
e,g.

let arrTuple: [number, string, number, string] = [501, "welcome", 505, "Mohan"];
console.log(arrTuple);

satisfies:
The satisfies operator is used to ensure that a value conforms to a specific type without changing the type of the value itself.

any and unkown:
any- mean anything
unkown- mean it is unkown now but it is kown or declare later

keyof:
keyof is a keyword in TypeScript which is used to extract the key type from an object type.

decorator:
its a special kind of declartion can be appleied to class, methods, argument, variable

Type assertions:
Type assertion is a technique that informs the compiler about the type of a variable.
Type assertion is similar to typecasting but it doesn’t reconstruct code.
You can use type assertion to specify a value’s type and tell the compiler not to deduce it.
e.g.

let str: unknown = "geeksforgeeks"; 
     console.log(str); 
     let len: number = (str as string).length; 
     console.log(len);

function overloading and overwritting:
overloading- i.e. changing number of parameters, change datatype of parameters, return type doesn’t play any role.
achieved at compile time.
overwriting-It is the redefinition of base class function in its derived class with same signature i.e. return type and parameters.
It can only be done in derived class.
achieved at run time.

want to know more about me, just write sallbro on search engine...

All About Javascript For Intermediate

Salman Asu — Fri, 22 Nov 2024 08:49:15 +0000

what is javascript:
javascript is an open source programing language. which help to create a dynamic web pages. it is also as browser language.
It can run on both the client-side (in browsers) and server-side (using environments like Node.js).
JavaScript supports event-driven, non-blocking, and asynchronous programming, which is essential for handling multiple tasks simultaneously.

varaible:
varaible are the container to store data
types of varaible

var
let
const

operators:
Javascript operators are used to perform different types of mathematical and logical computations.
types of operators

arithmetic = +,-,/,%,*
comparison
logical

data type
define the type of varaible

primitive data type = store the value by value

String
Number
Bigint
Boolean
Undefined = we declare the variable, value is not defined. datatype is undefined
Null = it is an assign value, we explicitly set the value as null. datatype is object
Symbol

non premitive data type = store the value by reference(address)

Object = Built-in object types can be: objects, arrays, dates, maps, sets, intarrays, floatarrays, promises
example:
null == undefined is true, but null === undefined is false.

The main difference between export and export default in JavaScript ?
is that export default is used to export a single value from a module,
while export with named exports is used to export multiple values

the main difference between primitive and non-primitive data types ?

is that primitive types are predefined, while non-primitive types are created by the programmer.
Primitive and Non-Primitive data structure that allows you to store only single data type values and to store multiple data type values. Primitive data types are stored directly in memory, whereas non-primitive data types are stored as references to their values in memory.
primitive data types are passed by value and non-primitive data types are passed by reference.
Primitive data types are immutable, meaning their values cannot be changed once assigned. Non-primitive data types are mutable and can be modified.
Numbers, strings, and booleans are examples of primitive data types, while objects, arrays, and functions are examples of non-primitive data types.

function:
A JavaScript function is a block of code designed to perform a particular task.

Is javascript a statically typed or a dynamically typed language?
JavaScript is a dynamically typed language. In a dynamically typed language,
the type of a variable is checked during run-time in contrast to a statically typed language,
where the type of a variable is checked during compile-time.

Explain passed by value and passed by reference ?
In JavaScript, primitive data types are passed by value and non-primitive data types are passed by reference.
primitive data types = string, number, boolean, null, undefined
non-primitive data types = objects, arrays

What do you mean by strict mode in javascript and characteristics of javascript strict-mode ?
allows you to write a code or a function in a strict operational environment.
As a result, debugging becomes a lot simpler.

What are factory functions in JavaScript ?
If we have complex logic, and we have to create multiple objects again and again that have the same logic,
we can write the logic once in a function and use that function as a factory to create our objects.
It’s the same as a real-world factory producing products.
a factory function is a function that returns an object.

Higher Order Functions:
fuction take other fuction as an argument or return the function.
map, filter and reduce function are all example of HOF.
Higher-order functions are useful for tasks like event handling, data transformation (e.g., map and filter), and creating function factories or decorators.

Closures:
Closures are created when a function is defined inside another function,
and the inner function retains access to the variables and method in the outer function's scope
Closure provides a means to encapsulate data within functions, allowing for controlled access to that data while keeping it hidden from the outside scope.

callbacks:
Functions that are used as an argument to another function are called callback functions.
A callback is a function that will be executed after another function gets executed.
usecase of callback function when we want to perform asynchronous operation.

map() vs forEach()
map()=> Iterates over each element of an array and applies a transformation function to each element.
Does not modify the original array; it creates a new array with transformed elements.
forEach()=> Iterates over each element of an array and executes a provided callback function for each element.
Does not create a new array or modify the existing array; it only executes the callback function.

map() vs filter() vs reduce()
map()it will return new array
filter() it is similar to map() it also return new array but if the condition is true. used when we want to apply condition.
reduce() it will return single value from an array.

this keyword:
The value of the this keyword will always depend on the object that is invoking the function.

currying:
transform a function of n argument to n function.
usecase enabling partial application(when you have a function that takes multiple arguments, but you only want to fix some of them, while leaving others open for later use),
reuse of code.
e.g

function add (a) {
  return function(b){
    return a + b;
  }
}
add(3)(4)

normal vs arrow function ?
normal function:
this refer to the object which call the function
can be use as a constructor
Function declarations are hoisted(allow hosting)
arrow function:
do not have their own this
cannot be use as a constructor
Function declarations are not hoisted(not allow hosting) // myfunc is not a function

normal and ternary condition ?
ternary condition store the refence without this context.

What is the difference between exec () and test () methods in javascript ?
test () and exec () are RegExp expression methods used in javascript.

some advantages of using External JavaScript?
We can reuse the code.
Code readability is simple in external javascript(code modularization)

prototype:
The JavaScript prototype property also allows you to add new properties and methods to objects constructors.
usecase for testing

memoization:
Memoization is a form of caching where the return value of a function is cached based on its parameters.
If the parameter of that function is not changed, the cached version of the function is returned.

DOM:
DOM stands for Document Object Model. DOM is a programming interface for HTML.
When the browser tries to render an HTML document, it create a DOM
Using this DOM, we can manipulate or change various elements inside the HTML document.

BOM:
Browser Object Model is known as BOM. It allows users to interact with the browser.
A browser's initial object is a window.

Promises:
Promises are used to handle asynchronous operations in javascript. Before promises, callbacks were used to handle asynchronous operations.
Promise object has four states -
Pending- Initial state of promise.
Fulfilled- This state represents that the promise has been fulfilled,.
Rejected- This state represents that the promise has been rejected.
Settled- This state represents that the promise has been either rejected or fulfilled.

async/await:
it is built on top of promises, it provide more consise way to write async code, making it easier to read and write.
async keyword is used to declare synction function and await is used to wait for promises to be resolved.

express vs structure
=>express is which return some value
e.g

const x=5;
const y=myfun();

5 and myfun() return some value is an expression
statement which instruct and order action, but does not return value
e.g.if,else, while are those are statement
while(i<2){}

rest parameter and spread operator:
rest parameter it combined the separate element into an array
spread operator is used to seperate array into single element

generator functions ?
They can be stopped midway and then continue from where they had stopped.
The generator object consists of a method called next(), this method when called, executes the code until the nearest yield statement, and returns the yield value.

call(),apply() and bind():
all these are use to assing object to this keyword(assign value to this keyword)
usecase when we want to manipulate this keyword of a fuction with desired object
The bind() method creates a new function that, when called, has its this keyword set to the provided value(e.g object). it create a new object.
call() and apply() serve the exact same purpose. The call() method does not make a copy of the function it is being called on.
The only difference between how they work is that call() expects all parameters to be passed in individually,
whereas apply() expects an array of all of our parameters.

IIFE:
immediately invoked function that run as soon as it defined.
e.g.

(function(){ 
  // Do something;
})();

pure function:
produce same output for same input. It takes place when the operands of an expression are of different data types.
function which does not modify the external state or varaible

Is javascript a statically typed or a dynamically typed language?
In a dynamically typed language, the type of a variable is checked during run-time in contrast to a statically typed language,
where the type of a variable is checked during compile-time.
e.g.
static type

string name="salman"; 
// varaible has types

dynamic type

var name="salman"; 
// convert into string at runtime

coercoin:
the automatic conversion of value from one data type to another.
String coercion
+ convert the number into string
- convert string into number

NaN():
isNaN() function converts the given value to a Number type, and then equates to NaN.

ASP script v/s javascript ?
ASP script runs on the server, while JavaScript runs on the client's browser.
ASP script is a server-side language used for handling complex tasks, such as database queries, form submissions, and user authentication.
while JavaScript is a client-side language used for creating interactive elements on web pages, such as animations, pop-up windows, and form validation.

Undefined Value:
value is not defined but variable is present
missing property in an object

eslint:
it help to debug and fine common vulnerablity in javascript code

want to know more about me, just write sallbro on search engine...

Full Guide For React Developer

Salman Asu — Fri, 22 Nov 2024 06:46:05 +0000

this post will help to understand all concept need to start working with projects.

let's begin !

(DOM) is a programming interface for web documents(page).
so that programs can change the document structure, style, and content.
The DOM represents the document as nodes and objects; that way, programming languages can interact with the page.

A component's lifecycle?
has three main phases: the Mounting Phase, the Updating Phase, and the Unmounting Phase.
The MountingPhase begins when a component is first created and inserted into the DOM.
The UpdatingPhase occurs when a component's state or props change.
And the UnmountingPhase occurs when a component is removed from the DOM.

what is components ?
Components are independent and reusable bits of code.
They serve the same purpose as JavaScript functions, but work in isolation and return HTML.
Components come in two types, Class components and Function components.

Class components and Function components difference ?

class components is more usefull when we want more controlled over every stage of lifecyle methode.
class component is traditional way for creating component.
with the help of hooks even now functional component can managed state. hooks was released in react 13.
Function components were considered "state-less". With the addition of Hooks, Function components are now almost equivalent to Class components.

react condition ?

Logical && Operator: e.g

{cars.length > 0 &&
      <h2>
        You have {cars.length} cars in your garage.
      </h2>
    }

Ternary Operator: e.g

condition ? true : false

usestate() ?
it is similar to variable in programming language. where we can store and update data or state.

useeffect() ?
it execute once when the component is created. and excute when there any change state added in depencency injection.
allow you to perform side effects such fetching data from an API, updating the DOM, or subscribing to an event.

useLayoutEffect() ?
The useLayoutEffect hook is similar to useEffect, but it’s executed synchronously after all DOM mutations.
This makes it useful for manipulating the DOM immediately after a component is rendered.
e.g. use useLayoutEffect to measure the size of an element

useReducer() ?
The useReducer Hook is similar to the useState Hook.
use when we want to manage more complex state management.
The useReducer Hook returns the current state and a dispatch method.

usecontext() ?
This hook in React is used to consume values from a React context.
It allows functional components to access the value provided by a context provider higher up in the component tree without the need for prop drilling.
Create a context e.g.

const MyContext = React.createContext();

Provide a value using Context Provider e.g.

<MyContext.Provider value={value}>

Consume the context value using useContext e.g.

const contextValue = useContext(MyContext);

e.g. React Context is a way to manage state globally.

useCallback() ?
Memoizes a function, preventing it from being recreated on every render if the dependencies remain unchanged.
Useful for optimizing performance by avoiding unnecessary re-renders of child components.

useMemo() ?
It memoizes a value, preventing it from being recomputed on every render if the dependencies remain unchanged.
It’s useful for optimizing expensive calculations or complex data transformations.

useref() ?
The useRef Hook allows you to persist values between renders.
It can be used to store a mutable value that does not cause a re-render when updated.
It can be used to access a DOM element directly.
Often used for accessing or manipulating DOM elements.

useimperativehandle() ?
hook allows you to customize the instance value that is exposed to parent components when using ref.
it's like certain adding interface to parenet components.

usedebugvalue() ?
that allows you to display custom debugging information for custom hooks in the React DevTools.

Explain the building blocks of React ?
Components: These are reusable blocks of code that return HTML.
JSX: It stands for JavaScript and XML and allows to write HTML in React.
Props and State: props are like function parameters and State is similar to variables.
Context: This allows data to be passed through components as props in a hierarchy.
Virtual DOM: It is a lightweight copy of actual DOM which makes DOM manipulation easier.

ReactJS Reconciliation ?
React Reconciliation is the process through which React updates the Browser DOM.
It updates the virtual DOM first and then uses the diffing algorithm to make efficient and optimized updates in the Real DOM.

React pure components ?
React pure components are the components that do not re-render when the value of props and state has been updated with the same values.

want to know more about me, just write sallbro on search engine...

Jumping From Javascript To Typscript Concept Should be Known

Salman Asu — Tue, 19 Nov 2024 13:24:08 +0000

really u want to learn ?
seriously !
let's begin,

Here’s a list of concepts to be aware of:

1.Types and Type Annotations

Basic Types: Understand the difference between string, number, boolean, any, void, undefined, null, etc.
Type Annotations: Learn how to declare types explicitly (e.g., let age: number = 30;).
Type Inference: TypeScript can infer types from context, but understanding when to use explicit types and when to rely on inference is important.
Union Types: Types can be a combination of multiple types (e.g., let value: string | number).
Literal Types: Types that can be specific values (e.g., let direction: 'left' | 'right';).

2. Interfaces and Type Aliases

Interfaces: Used to define object shapes (e.g., interface User { name: string; age: number }).
Type Aliases: Allows you to create custom types (e.g., type ID = string | number;).
Differences between Interfaces and Types: Interfaces are extendable, while type aliases are more flexible (can define primitives, unions, intersections, etc.).

3. Generics

Generic Functions: Functions that can work with multiple types (e.g., function identity<T>(arg: T): T { return arg; }).
Generic Interfaces/Classes: Apply generics to interfaces and classes (e.g., interface Box<T> { value: T; }).

4. Type Assertion and Casting

Type Assertions: Tells TypeScript that you know more about the type than it does (e.g., let value = someValue as string).
Non-Null Assertion: Use ! to tell TypeScript that a value is not null or undefined (e.g., someVar!.doSomething()).

5. Structural Typing (Duck Typing)
In TypeScript, types are structural, meaning that types are compared based on their properties, not their names. If two types have the same structure, they are considered the same type.

6. Enums

Numeric and String Enums: Allows you to define a set of named constants (e.g., enum Direction { Up, Down, Left, Right }).
Const Enums: A more efficient form of enums when no reverse mapping is needed (e.g., const enum Color { Red, Green, Blue }).

7. Type Narrowing

Type Guards: Use typeof, instanceof, or custom type predicates to narrow down the type of a variable.
Discriminated Unions: Combining union types with a common property (discriminator) to narrow down types (e.g., type Circle = { kind: "circle"; radius: number };).

8. Advanced Types

Intersection Types: Combine multiple types into one (e.g., type AdminUser = User & Admin;).
Mapped Types: Allows you to transform properties in a type (e.g., type ReadOnly = { readonly [P in keyof T]: T[P]; }). Utility Types: Built-in types that simplify common type transformations, such as Partial, Pick, Omit, Record, etc.

9. Modules and Namespaces

ES Modules: TypeScript supports ES6 module syntax (e.g., import/export). Understanding module resolution and the difference between default and named exports is essential.
Namespaces: TypeScript also has its own namespace system, but it's generally discouraged in favor of ES modules for modern codebases.

10. Handling JavaScript Libraries

DefinitelyTyped: Learn how to install and use type definitions for JavaScript libraries that don't provide their own types (e.g., via @types/lodash).
Declaring Types for 3rd-Party Libraries: Know how to write custom type declarations (*.d.ts files) for libraries or global objects when no types are available.

11. Classes and Inheritance

TypeScript Classes: Similar to JavaScript classes but with additional type-checking.
Access Modifiers: public, private, protectedkeywords control the visibility of class members.
Readonly: Marks properties as read-only (e.g., readonly id: number).
Abstract Classes and Methods: Abstract classes cannot be instantiated directly and are meant to be subclassed.

12. Async/Await and Promises
TypeScript has full support for async/await and Promises, but adding type annotations can help avoid issues with types like Promise or async function.

13. Decorators
Experimental Feature: Decorators are a special syntax for annotating or modifying classes and class members. Useful in frameworks like Angular, but still experimental in TypeScript.

14. Strict Type-Checking Options

Strict Mode: Enables stricter type-checking options (e.g., strictNullChecks, noImplicitAny).
tsconfig.json: Learn how to configure TypeScript using this file to enable or disable compiler options.

15. TypeScript and JavaScript Interoperability

Working with JavaScript Code: TypeScript is fully compatible with JavaScript. You can gradually introduce TypeScript into an existing JavaScript project and still call JavaScript from TypeScript and vice versa.
JSDoc Comments: You can use JSDoc-style comments in JavaScript to provide type information to TypeScript, which is useful in mixed JS/TS codebases.

16. Error Handling
TypeScript helps catch common errors at compile time, such as accessing properties on null or undefined. Understanding how to use try/catch in TypeScript, along with proper type annotations, is important.

17. TypeScript Configuration (tsconfig.json)

Compiler Options: Learn how to configure compiler settings, including module resolution, strictness settings, and target environments.
Source Maps: Set up source maps to make debugging TypeScript in the browser or Node.js easier.

18. Utility Functions and Types

keyof, typeof, instanceof: Understand these utility operators and how to use them to extract and manipulate types.
Index Signatures: Allow you to define the types of keys and values for objects dynamically (e.g., [key: string]: any).

19. Conditional Types
TypeScript allows defining types based on conditions (e.g., type IsString<T> = T extends string ? true : false;).

20. TypeScript Versioning and Compatibility

New Features: Stay updated with new TypeScript versions, as it’s a rapidly evolving language. New features like template literal types, type predicates, and stricter type checking can improve your code.

By mastering these TypeScript-specific concepts, you'll be able to leverage the full power of TypeScript, including its static type system, for improved code quality, maintainability, and scalability compared to plain JavaScript.

want to know more about me, just write sallbro on search engine...

NIST Defination of cloud computing with Diagram

Salman Asu — Sun, 01 Sep 2024 14:32:17 +0000

Defination:

The National Institute of Standards and Technology (NIST) defines cloud computing as a model for enabling convenient, ondemand network access to a shared pool of configurable computing resources (e.g., networks, servers, storage, applications, and services) that can be rapidly provisioned and released with minimal management effort or service provider interaction.

Deployment Models:

Cloud computing has revolutionized the way businesses operate, offering scalable resources and flexible solutions tailored to meet diverse needs. One of the critical aspects of cloud computing is understanding the different deployment models available. These models determine how cloud services are delivered and managed, each with unique benefits and trade-offs. In this article, we’ll delve into the primary cloud deployment models: Public Cloud, Private Cloud, Hybrid Cloud, and Multi-Cloud.

1. Private Cloud:

Overview

A private cloud is a cloud environment dedicated to a single organization, either hosted on-premises or by a third-party provider. This model offers enhanced control over data, security, and compliance.

Key Features

Enhanced Security: Dedicated infrastructure reduces the risk of data breaches.
Customization: Tailored to meet specific business and regulatory requirements.
Performance: Often provides better performance for certain workloads due to dedicated resources.

Use Cases

Large Enterprises: Require robust security and compliance for sensitive data.
Financial Institutions: Need to comply with strict regulatory requirements.
Healthcare Providers: Handle sensitive patient data securely.

Pros and Cons

Pros: Greater control and security, customizable infrastructure, compliance benefits.
Cons: Higher costs, requires in-house expertise to manage, less scalable compared to public cloud.

2. Community Cloud

Overview

A community cloud is a collaborative cloud infrastructure shared by several organizations with common goals or requirements. These organizations often belong to a specific community, such as healthcare, finance, or government, and share the infrastructure to address common concerns like security, compliance, and performance.

Key Features

Shared Resources: Infrastructure is shared among organizations with similar needs, reducing costs.
Compliance and Security: Tailored to meet the specific regulatory and security requirements of the community.
Collaboration: Facilitates collaboration among community members, enabling shared projects and initiatives.

Use Cases

Healthcare Organizations: Share infrastructure for patient data management, ensuring compliance with health regulations.
Financial Institutions: Collaborate on secure transaction processing and regulatory reporting.
Government Agencies: Share resources for public administration and citizen services.

Pros and Cons

Pros: Cost-effective, enhanced security and compliance, fosters collaboration.
Cons: Limited scalability compared to public cloud, potential governance and management challenges, dependency on community agreements.

3. Public Cloud

Overview

The public cloud is the most common deployment model, where cloud services are delivered over the internet by third-party providers. Examples include Amazon Web Services (AWS), Microsoft Azure, and Google Cloud Platform (GCP). These providers offer a range of services, from storage and computing power to advanced machine learning tools.

Key Features

Scalability: Easily scale resources up or down based on demand.
Cost-Effectiveness: Pay-as-you-go pricing models help reduce capital expenditure.
Accessibility: Services are accessible from anywhere with an internet connection.

Use Cases

Startups and Small Businesses: Low upfront costs and scalability make it ideal for growing companies.
Development and Testing: Rapid provisioning of resources for development environments.
E-commerce Platforms: Handle variable traffic loads efficiently.

Pros and Cons

Pros: High scalability, cost-effective, no maintenance overhead.
Cons: Potential security and compliance concerns, less control over infrastructure.

4. Hybrid Cloud

Overview

The hybrid cloud combines both public and private clouds, allowing data and applications to be shared between them. This model provides the flexibility of the public cloud with the security of the private cloud.

Key Features

Flexibility: Workloads can be moved between public and private clouds based on needs.
Cost Optimization: Utilize public cloud resources for non-sensitive tasks and private cloud for sensitive workloads.
Disaster Recovery: Enhanced backup and recovery solutions by leveraging multiple environments.

Use Cases

Seasonal Workloads: Manage variable workloads by scaling out to the public cloud during peak times.
Data Processing: Use private cloud for sensitive data and public cloud for large-scale data processing.
Business Continuity: Implement disaster recovery solutions across both environments.

Pros and Cons

Pros: Balanced cost and control, enhanced flexibility, improved disaster recovery.
Cons: Complex to manage, potential compatibility issues, requires robust network connectivity.

Delivery Models:

Cloud computing has become an integral part of modern IT infrastructure, providing scalable, on-demand resources that drive innovation and efficiency. The way cloud services are delivered is categorized into several models, each serving different needs and applications. These delivery models are Infrastructure as a Service (IaaS), Platform as a Service (PaaS) and Software as a Service (SaaS).Understanding these models is crucial for businesses to make informed decisions and leverage the benefits of cloud computing effectively.

1. Infrastructure as a Service (IaaS)

Overview

IaaS is the foundational layer of cloud services, providing virtualized computing resources over the internet. With IaaS, businesses can rent infrastructure such as servers, storage, and networking on a pay-as-you-go basis, eliminating the need for physical hardware.

Key Features

Scalability: Easily scale resources up or down based on demand.
Cost Efficiency: Reduce capital expenditure by paying only for what you use.
Flexibility: Configure and manage infrastructure according to specific needs.

Use Cases

Disaster Recovery: Implement cost-effective backup and recovery solutions.
Development and Testing: Quickly provision and decommission environments for software development.
Website Hosting: Host websites and web applications with flexible resource allocation.

Pros and Cons

Pros: High scalability, cost-effective, flexible and customizable.
Cons: Requires expertise to manage, potential security risks if not configured correctly.
Examples

Amazon Web Services (AWS) EC2
Microsoft Azure Virtual Machines
Google Compute Engine (GCE)

2. Platform as a Service (PaaS)

Overview

PaaS provides a platform allowing customers to develop, run, and manage applications without dealing with the underlying infrastructure. This model includes tools and services for application development, such as operating systems, databases, and development frameworks.

Key Features

Development Tools: Integrated development environments (IDEs), version control, and testing services.
Middleware: Support for application hosting, database management, and messaging services.
Automation: Automated provisioning and scaling of resources.

Use Cases

Application Development: Streamline the development, testing, and deployment of applications.
APIs and Microservices: Develop and manage APIs and microservices efficiently.
Enterprise Applications: Build and deploy scalable enterprise applications without infrastructure concerns.

Pros and Cons

Pros: Accelerates development, reduces management overhead, supports collaborative work.
Cons: Less control over underlying infrastructure, potential vendor lock-in.
Examples

Google App Engine
Microsoft Azure App Services
Heroku

3. Software as a Service (SaaS)

Overview

SaaS delivers software applications over the internet on a subscription basis. Users access software via a web browser, eliminating the need for installation and maintenance. This model is widely used for business applications, such as email, customer relationship management (CRM), and collaboration tools.

Key Features

Accessibility: Access applications from any device with an internet connection.
Maintenance: The provider handles software updates, security, and maintenance.
Subscription-Based: Pay-as-you-go pricing with different subscription tiers.

Use Cases

Business Applications: Use applications like CRM, ERP, and office productivity tools.
Collaboration Tools: Facilitate team collaboration with tools like Slack and Microsoft Teams.
Customer Support: Implement customer support solutions like Zendesk.

Pros and Cons

Pros: Easy to use, reduces IT management burden, scalable.
Cons: Limited customization, data security concerns, dependency on internet connectivity.
Examples

Salesforce
Google Workspace
Microsoft Office 365

> Essential Characteristics:
On-Demand Self-Service: Users can provision computing resources as needed automatically, without requiring human interaction with each service’s provider.
Ubiquitous Network Access: Services are accessible over the network via standard mechanisms, promoting use across a wide range of devices and platforms.
Rapid Elasticity: Resources can be quickly scaled up or down to meet demand, ensuring efficient utilization and responsiveness.
Location-Independent Resource Pooling: Resources are pooled to serve multiple users, with different physical and virtual resources dynamically assigned and reassigned according to demand.
Measured Service: Cloud systems automatically control and optimize resource use by leveraging a metering capability, typically providing transparency for both the provider and consumer of the utilized service.