I’ve been building AI agents non-stop since November 2024, and I’d like to share some of the things I’ve learned and how I approach building them.

I’m the kind of person who prefers doing things from scratch, especially when working with technologies that are new to me. That means I don’t rely on popular libraries—other than the standard SDKs from LLM providers. So, if you’re expecting fancy frameworks, there’s nothing to see here. This is all about pure logic.

My agent architecture : 
IO <-> Agent Router <-> Business-Specific Agent <-> LLM Service <-> Providers

IO: 
This is the standard input/output layer, handling request validation, authentication, etc.

Agent Router:   

Depending on the business logic, I either route agents by project/task status or, in some cases, use tool calls from a primary agent (e.g., a planner agent) to handle routing.

Business-Specific Agent:  

This is where the agent’s core logic lives. It iterates (loops) until the task is completed or until it needs to send a message back to the user. In this layer, I define which model strategies to use, what prompts to provide, which tools to provide and the context to maintain across iterations. To avoid runaway loops, I also implement a safety max iteration limit—if the agent reaches this limit, it pauses and prompts the user for approval before continuing.

Context Handling:  

For agents that primarily work with tools, I usually provide the 2-3 most recent messages in raw form and prior messages in summarized form to keep context efficient. Agents also have access to a context set/get tool that allows them to save multi-step work and retrieve it later when needed. This is crucial for handling workflows that span multiple steps or require persistent memory during a task.  

LLM Service:  

Acts as a router for different LLM providers. Here, I handle API request logging, error logging, token usage tracking, and retries. Based on error codes, I might retry with the same model strategy or switch to a different one. Some agents support multiple models, so retrying with alternate strategies is common.

Providers:  

I primarily use Google Gemini and OpenAI models because they’re free during development (via Gemini’s free tier and GitHub Models API). Claude models are undeniable when building coding agents but other than that, I use Google and OpenAI models.

Mock Provider:  

I also use a mock provider that returns predefined responses based on the user’s message count or specific keywords. This is extremely helpful for developing workflow agents—you get predictable, fast responses and can focus on the application side without waiting for actual LLM outputs. Highly recommended.

Human Provider:   

There’s also a “manual provider” where I send responses manually through a special route, effectively acting in place of the AI agent. This is useful for reviewing tool call results and the context provided to the LLM. Building AI agents is all about context and tools—if the tools you give your agents aren’t effective, they’ll fail no matter which model you use. This one’s also highly recommended.

Evals:  
I treat evals like test cases in traditional software engineering. I group eval sets into levels: easy, difficult, edge cases, etc. Each eval defines the task for the agent, success criteria, expected scores, and the minimum/maximum tool calls. I don’t do anything fancy here—I run them manually to see if the agents behave as expected. (There might be better processes I haven’t explored yet.)

This is the way I build AI agents today. 

Thank You.




I’ve been building AI agents non-stop since November 2024, and I’d like to share some of the things I’ve learned and how I approach building them...

Add a heading.png

Here’s how I build AI agents in 2025




Hey there, fellow coders! Ever wished your code could be more adaptable and reusable without turning into a puzzle? Well, say hello to TypeScript Generics! In this blog post, we're going to take a stroll through the basics of TypeScript Generics - a fancy term for making your code super flexible. No jargon, no headaches, just a straightforward guide to help you write code that can handle different data types like a champ. Let's dive in and make your coding life a bit simpler, shall we?

## What are Generics?

Generics are a tool that allows you to write flexible, reusable code while maintaining type safety. They are a way of creating reusable components that can work over a variety of types rather than a single one. Imagine you're writing a function to return the last item in an array. Without generics, you might write something like this:

```typescript
function getLastItem(arr: any[]) {
    return arr[arr.length - 1];
}
```

This works, but we lose information about the type of the returned item. With generics, we can write:

```typescript
function getLastItem<T>(arr: T[]): T {
    return arr[arr.length - 1];
}
```

Here, `T` is a type variable—a stand-in for any type. This version of the function has the same functionality, but now it also preserves the type information.

## Example Use Cases

### 1. Creating a Linked List

Generics are often used in data structures. For example, here's how you might define a simple linked list node in TypeScript:

```typescript
class ListNode<T> {
    constructor(public value: T, public next: ListNode<T> | null = null) {}
}
```

### 2. Promise Return Types

When working with Promises, TypeScript's built-in `Promise<T>` type makes it easy to know what type of data a promise will resolve with:

```typescript
function getEmployee(id: string): Promise<Employee> {
    // Implementation here...
}
```

In this example, `Promise<Employee>` is a generic type that indicates the promise will resolve with an instance of the `Employee` class.

### 3. Creating a Reusable Box Class
Generics are not just for functions; you can use them in classes too. Here's a simple Box class that can hold any type of value:

```typescript

class Box<T> {
  private value: T;

  constructor(value: T) {
    this.value = value;
  }

  getValue(): T {
    return this.value;
  }
}

const stringBox = new Box('TypeScript');
const numberBox = new Box(42);

console.log(stringBox.getValue()); // 'TypeScript'
console.log(numberBox.getValue()); // 42
```

### 4. Working with Generic Constraints
You can also set constraints on the types that can be used with generics. In this example, we ensure that the input type must have a length property:

```typescript

function logLength<T extends { length: number }>(value: T): void {
  console.log(value.length);
}

logLength('Hello, TypeScript!'); // 18
logLength([1, 2, 3, 4, 5]);      // 5
```

### 5. Using Type Parameters in Generic Constraints   

You can declare a type parameter that is constrained by another type parameter. For example, here we’d like to get a property from an object given its name. We’d like to ensure that we’re not accidentally grabbing a property that does not exist on the obj, so we’ll place a constraint between the two types:

```
function getProperty<Type, Key extends keyof Type>(obj: Type, key: Key) {
  return obj[key];
}
 
let x = { a: 1, b: 2, c: 3, d: 4 };
 
getProperty(x, "a");
getProperty(x, "m");
Argument of type '"m"' is not assignable to parameter of type '"a" | "b" | "c" | "d"'.
```


And there you have it! We've taken a stroll through the world of TypeScript Generics, unlocking the magic of flexibility and reusability in our code. With Generics, coding becomes a breeze. Whether you're creating functions that work seamlessly with different data types or crafting versatile classes, TypeScript Generics empowers you to write code that's not just functional but adaptable to whatever you throw at it. I encourage you to read more details about it on TypeScript official website here :   [https://www.typescriptlang.org/docs/handbook/2/generics.html](https://www.typescriptlang.org/docs/handbook/2/generics.html)



Generics are a tool that allows you to write flexible, reusable code while maintaining type safety. They are a way of creating reusable components that can work over a variety of types rather than a single one.

maxresdefault (1).jpg

Learn TypeScript Generics with Examples



If you've been working with JavaScript in the realms of React, Node.js, or any other project, you've likely come across the term "Higher-Order Functions" (HOFs). They're a powerful concept that can help you write cleaner, more modular, and reusable code. In this blog post, we'll break down what Higher-Order Functions are and explore various use cases for them.

### What Are Higher-Order Functions?   

Higher-Order Functions, or HOFs for short, are functions in JavaScript that can do one or both of the following:

1. Take other functions as arguments.
2. Return functions as their results.

In simpler terms, think of HOFs as functions that work with other functions. They are versatile tools that allow you to abstract and encapsulate behavior, making your code more flexible and maintainable.

Now, let's dive into practical use cases for Higher-Order Functions, along with code samples on how to use them.

### 1. Creating Reusable React Components   

In React, Higher-Order Components (HOCs) are a classic example of HOFs. They take a component as input and return a new component with enhanced functionality. Here's an example:


```
const withLogger = (WrappedComponent) => {
  return function WithLogging(props) {
    console.log(`Rendering: ${WrappedComponent.name}`);
    return <WrappedComponent {...props} />;
  };
};

const BetterComponent = withLogger(MyComponent);

```

In this example, `withLogger` is a Higher-Order Function that adds logging capabilities to any React component, allowing you to use `BetterComponent` in your application.


### 2. Creating Reusable React Hooks  

React custom hooks are another way to leverage Higher-Order Functions. Create custom hooks that abstract common behavior and reuse them across components. Here's a simple example of how to use a custom hook:


```

const useCounter = (initialValue) => {
  const [count, setCount] = useState(initialValue);

  const increment = () => {
    setCount(count + 1);
  };

  return { count, increment };
};

// In a component:
const CounterComponent = () => {
  const { count, increment } = useCounter(0);

  return (
    <div>
      <p>Count: {count}</p>
      <button onClick={increment}>Increment</button>
    </div>
  );
};


```

### 3. Creating API Calls with Token   

When working with APIs, you can use HOFs to create a function that handles authentication and token management. Here's how to use a Higher-Order Function for making authenticated API calls:


```

const withAuthToken = (apiFunction, authToken) => {
  return async (url, data) => {
    const headers = {
      Authorization: `Bearer ${authToken}`,
    };

    return await apiFunction(url, data, headers);
  };
};


// To use the withAuthToken function:
const authenticatedApiCall = withAuthToken(apiCallFunction, 'yourAuthToken');

// Now, you can use authenticatedApiCall to make API requests with authentication.

```


### 4. Creating Testable Components   

Higher-Order Functions can make your components more testable. You can create a HOF that abstracts side effects or dependencies, allowing you to easily mock or replace them during testing. Here's how to use such a function:


```

const withApiService = (Component, apiService) => {
  return function WithApiService(props) {
    return <Component {...props} apiService={apiService} />;
  };
};

// In your component:
const MyComponent = ({ apiService }) => {
  // Use apiService to make API requests.

  // ...
};

const TestableComponent = withApiService(MyComponent, mockedApiService);

// Now, you can use TestableComponent for testing with the mocked API service.


```

### 5. Creating Reusable Error Handler/Functions in Node.js   

You can also use Higher Order Functions in Nodejs. For example, you can create HOFs that manage error handling or middleware functions in an Express.js application. Here's how to use such a function:


```

const errorHandler = (handler) => {
  return async (req, res, next) => {
    try {
      await handler(req, res);
    } catch (error) {
      // Handle and log the error
      next(error);
    }
  };
};

// In your Express.js routes:
app.get('/myRoute', errorHandler(async (req, res) => {
  // Your route logic here. No need to handle errors anymore here.
}));


```

In conclusion, Higher-Order Functions are a fundamental concept in JavaScript that can greatly enhance code reusability, modularity, and maintainability. Whether you're working with React, Node.js, or any other JavaScript project, I believe understanding and effectively using HOFs can make your code more powerful and maintainable. So go ahead, leverage the power of Higher-Order Functions in your projects and write cleaner, more efficient code.


Higher-Order Functions are a fundamental concept in JavaScript that can greatly enhance code reusability, modularity, and maintainability.

Untitled (1).png

Higher Order Functions in JavaScript with Examples

Flutter is a powerful framework for building beautiful and engaging mobile apps. However, with so many available packages, it can be overwhelming to know which ones are right for your project. In this blog post, I will share a variety of Flutter packages that I personally think essential to help you streamline your development process and build feature-rich apps.



##### State Management, Dependency Injection, and Routing:

[Get](https://pub.dev/packages/get)  
Get is a state management, routing, and dependency injection package for Flutter. It is known for being easy to use and promoting clean code. Some of the features of Get include reactive state management, automatic dependency injection, and the ability to navigate without context.

[Riverpod](https://pub.dev/packages/riverpod)  
Riverpod is a reactive caching and data-binding framework for Flutter. It simplifies working with asynchronous code by automatically handling errors and loading states. It also separates the logic from the UI and ensures code is testable and reusable.

##### UI Enhancement & Animations:

[flutter_native_splash](https://pub.dev/packages/flutter_native_splash)   
This package is used to customize the splash screen in a Flutter app. It allows you to set the background color and image of the splash screen. The package also supports dark mode and platform-specific options.

[carousel_slider](https://pub.dev/packages/carousel_slider)  
This package can be used to create a carousel slider widget for displaying images or text in Flutter apps. The widget supports infinite scrolling and allows for customization of the child widgets.

[introduction_screen](https://pub.dev/packages/introduction_screen)  
It helps you create an introduction screen for your app. The package includes a number of widgets that can be used to create the introduction screen, and it is easy to use and customizable.


[flutter_custom_clippers](https://pub.dev/packages/flutter_custom_clippers)   
It provides custom clippers to help achieve various shapes in Flutter apps. The package includes a number of different clippers, including SideCutClipper, MultipleRoundedCurveClipper, and MultiplePointedEdgeClipper. Each clipper can be used to create a specific shape by clipping a widget. For example, the SideCutClipper can be used to create a widget with a diagonal cut on one side.

[animations](https://pub.dev/packages/animations)   
This package provides pre-built animations for Flutter applications. It includes Material motion, a set of transition patterns that helps users navigate an app. The package also includes common animation patterns like container transform, shared axis, fade through, and fade.

[flutter_animate](https://pub.dev/packages/flutter_animate)   
It allows you to add animations to your widgets. It includes pre-built effects like fade, scale, slide, align, flip, blur, shake, shimmer, shadows, crossfades, follow path, and color effects. It also allows you to apply animated GLSL fragment shaders to widgets.

[flame](https://pub.dev/packages/flame)   
It is a minimalist Flutter game engine that provides a nice set of somewhat independent modules you can choose from. It is Dart 3 compatible and works on multiple platforms including Android, iOS, Linux, macOS, web, and Windows. Some of the key features of Flame include a game loop, a component/object system, effects and particles, collision detection, gesture and input handling, images, animations, sprites, and sprite sheets, and general utilities to make development easier.

[responsive_framework](https://pub.dev/packages/responsive_framework)   
It helps you make Flutter apps responsive. The package includes widgets that help developers build responsive apps for mobile, desktop, and website layouts. The core functionality is achieved through the use of breakpoints, which define different screen sizes and the corresponding UI behavior. Developers can define custom breakpoints and use them to control how their UI displays at different screen sizes.

##### Networking & Data Storage:

[dio](https://pub.dev/packages/dio)   
Dio is a powerful HTTP networking package for Flutter and Dart. It features interceptors, transformers, and error handling. Dio can be used to make GET, POST, and other types of requests. It can also be used to upload files.

[hive](https://pub.dev/packages/hive)   
Hive is a NoSQL database for mobile and web apps. It is lightweight, fast, and easy to use. Some of Hive’s features are strong encryption, cross-platform support, and the ability to store objects.

[graphql_flutter](https://pub.dev/packages/graphql_flutter)   
It brings the features of a modern GraphQL client to Flutter. It provides widgets and an API for interacting with GraphQL servers. It is easy to use and well documented.

[cached_network_image](https://pub.dev/packages/cached_network_image)   
This package is used to load and cache images from the internet in Flutter apps. It also supports placeholder and error widgets, which can be used to display content while the image is loading or if there is an error. 

[socket_io_client](https://pub.dev/packages/socket_io_client)   
It enables real-time communication between a web or Flutter application and a Socket.IO server. You can use it for features such as chatting, online games etc. It is available for various platforms including Android, iOS, Linux, macOS, and web browsers.

[web_socket_channel](https://pub.dev/packages/web_socket_channel)   
It is a collection of classes that enable communication between web applications and servers using WebSockets. This is similar to socket io client. It provides a consistent API across different platforms (Android, iOS, Linux, macOS, web, and Windows).

[json_serializable](https://pub.dev/packages/json_serializable)   
It helps you automatically generate code to convert Dart classes to and from JSON. The package uses annotations to mark classes and fields for conversion. It can also handle custom types and encoding.


##### Forms & User Input:

[flutter_form_builder](https://pub.dev/packages/flutter_form_builder)  
It helps you create forms in Flutter. The package helps remove boilerplate code, reuse validation, react to changes, and collect user input. It includes common pre-made form fields.

[flutter_typeahead](https://pub.dev/packages/flutter_typeahead)   
It allows you to create a typeahead (autocomplete) text input field for your Flutter applications. It is highly customizable, meaning that developers can change many aspects of how the typeahead field looks and behaves.

##### Text & Markdown:

[google_fonts](https://pub.dev/packages/google_fonts)  
This package allows you to use fonts from Google Fonts in your Flutter app. It supports HTTP fetching, caching, and asset bundling. Fonts can be downloaded from fonts.google.com and placed in an asset folder in your pubspec.yaml file.

[flutter_markdown](https://pub.dev/packages/flutter_markdown)   
It is a renderer for Markdown, a lightweight markup language, into a Flutter widget containing a rich text representation. It supports the original format, but no inline HTML. 

[readmore](https://pub.dev/packages/readmore)   
It allows you to expand and collapse text dynamically. It is useful for situations where you have a large amount of text that you don't want to overwhelm the user with all at once.

[auto_size_text](https://pub.dev/packages/auto_size_text)   
It allows you to set the font size of a Text widget to automatically adjust to fit its container. This is useful for situations where you want the text to always be visible within the available space. 


##### Navigation & Deep Linking:

[flutter_launcher_icons](https://pub.dev/packages/flutter_launcher_icons)   
This package simplifies the process of updating launcher icons for Flutter apps. It supports Android, iOS, macOS, and Windows platforms. It also supports generating icons for web apps.

[uni_links](https://pub.dev/packages/uni_links)   
It allows you to handle universal links on both Android and iOS. Remember when you click a link on mobile and it offers to open the link with an app other than a browser, this package is for that. 

[firebase_dynamic_links](https://pub.dev/packages/firebase_dynamic_links)   
It is an app solution for creating and handling links across multiple platforms. This is similar to uni_links package but the links are setup by Firebase which makes it easier. 

[go_router](https://pub.dev/packages/go_router)   
It is a declarative routing package for Flutter that uses the Router API to provide a convenient, url-based API for navigating between different screens. It supports a number of features including: defining URL patterns, navigation using a URL, handling deep links, and more.

[infinite_scroll_pagination](https://pub.dev/packages/infinite_scroll_pagination)   
It helps us lazily load and display pages of items as the user scrolls down the screen. It is designed to be unopinionated, extensible, and highly customizable. This means that it can be used with any state management approach, layout, or API. The package also provides built-in widgets for common layouts, such as GridView, SliverGrid, ListView, and SliverList. Developers can also create custom layouts if needed.

##### Development & Testing:

[mockito](https://pub.dev/packages/mockito)  
It allows you to create mock objects for testing purposes. It provides APIs for Fakes, Mocks, behavior verification, and stubbing. Mockito is inspired by Mockito, a popular mocking framework for Java.

[in_app_update](https://pub.dev/packages/in_app_update)   
It enables In App Updates on Android using the official Android APIs. It cannot be used on iOS devices though.

[flutter_gen](https://pub.dev/packages/flutter_gen)   
It helps you generate Dart code to replace string-based APIs for assets, fonts, and colors in your Flutter application. This can help to improve the maintainability and readability of your code.

[freezed](https://pub.dev/packages/freezed)   
It is used to generate code for immutable classes. It is used to simplify data-class/union/pattern-matching/cloning. Freezed achieves this by generating a number of methods including a copyWith method, a toString override, and operator == and hashCode overrides.

[sentry_flutter](https://pub.dev/packages/sentry_flutter)   
This is official sentry package. It helps track errors and performance in Flutter apps. It supports various Flutter targets through native SDKs. It captures errors in the native layer, including Java/Kotlin/C/C++ for Android and Objective-C/Swift for iOS.

[logger](https://pub.dev/packages/logger)   
It helps you print logs to the console. It can be used to print different levels of logs, such as trace, debug, info, warning, error, and fatal. You can also customize the output of the logs, such as by adding colors or timestamps.


##### Other:
[permission_handler](https://pub.dev/packages/permission_handler)   
It allows you to request and check permissions on Android and iOS devices. It provides a cross-platform API and also allows you to open the device's app settings if a user denies a permission. On Android, you can show a rationale for why you are requesting a permission.

[flutter_inappwebview](https://pub.dev/packages/flutter_inappwebview)  
It allows you to add an inline webview, use a headless webview, and open an in-app browser window. The plugin is compatible with Dart 3, and supports Android, iOS, macOS, and web platforms.

[uuid](https://pub.dev/packages/uuid)   
It helps you generate Universally Unique Identifiers (UUIDs). The package supports generating different versions of UUIDs including v1, v4, and v5. It also supports draft versions 6, 7, and 8. The package is well documented and includes examples.

[share_plus](https://pub.dev/packages/share_plus)   
It allows you to share content from your Flutter app via the platform's share dialog. It wraps the ACTION_SEND Intent on Android and UIActivityViewController on iOS.
This plugin supports sharing text, files, and links. You can also specify a subject for the share and a custom share position origin for iPad users.


This post has only scratched the surface of the amazing Flutter package ecosystem. With countless options available, the possibilities for building unique and engaging apps are endless. So, I encourage you to dive deeper into the ones that pique your interest, and unleash your creativity to build fantastic Flutter apps!


With so many available packages, it can be overwhelming to know which ones are right for your project. 

_daeebadb-55a1-40ca-a9d3-17e4474f22b6.jpeg

Flutter Packages That Make My Life Easier



As a software developer, I’ve encountered my fair share of bugs and errors. It’s an inevitable part of the development process. However, what distinguishes a good developer from a great one is not just the ability to write error-free code, but the skill to handle errors effectively when they do occur. This is why I’ve decided to share my two cents on error handling in JavaScript projects.

Error handling is a critical component of any project. It ensures that your application can gracefully manage unexpected situations, maintain its functionality, and provide a seamless user experience. In this blog post, we’ll explore the various facets of error handling in JavaScript. We’ll start with the basics, such as understanding different types of errors and using the try...catch statement, and gradually move towards more advanced topics like handling token expiration and network issues.

By the end of this post, I hope you’ll have a comprehensive understanding of error handling that will elevate your JavaScript projects from merely functioning to truly robust and reliable. So, join me as we navigate the intricacies of JavaScript error handling together.



### Fundamentals of Error Handling
In this section, we’ll cover the three primary types of errors you’ll encounter in JavaScript: syntax errors, runtime errors, and logical errors. Understanding these will help you write more resilient code.

##### Syntax Errors
Syntax errors are mistakes in the use of the JavaScript language. These are typically caught by the interpreter when it tries to compile the script. A common tool to catch these errors is [ESLint](https://eslint.org/), a static code analysis tool that identifies problematic patterns in JavaScript code. It can catch everything from stylistic errors to potential bugs:


```
// ESLint can catch simple syntax errors
const greeting = 'Hello, world'
console.log(greeting);

```
In the example above, if your ESLint rules require a semicolon at the end of each statement, it would flag the missing semicolon after the greeting declaration.


##### Runtime Errors
Runtime errors, also known as exceptions, occur while the program is running. JavaScript provides a try...catch statement that allows you to handle these errors gracefully:



```
try {
  // Code that may throw an error
  myFunction();
} catch (error) {
  // Code to handle the error
  console.error(error);
}

```


The try block contains the code to be executed, and the catch block allows you to define a response to any errors thrown. It’s important to use try...catch judiciously, as overuse can lead to performance issues and make the code harder to read and maintain.


##### Logical Errors  
Logical errors occur when the code doesn’t perform as expected, but it doesn’t necessarily crash or throw an error. These are often the hardest to diagnose because the code is syntactically correct. To handle logical errors:

Write unit tests to ensure your code behaves as expected.
Use debugging tools to step through your code and inspect variables.
Review your logic and algorithms carefully to ensure they’re correct.
Here’s an example of a logical error and how you might catch it:


```
function calculateArea(width, height) {
  // A logical error: using addition instead of multiplication
  return width + height; // Should be width * height
}

const area = calculateArea(5, 4);
if (area !== 20) {
  console.error('There is a logical error in the calculateArea function');
}

```

In the example, the calculateArea function incorrectly adds the width and height instead of multiplying them. The conditional check after the function call is a simple way to assert that the function’s output is as expected. 
 

### Advanced Error Handling Strategies  
##### Custom Error Classes   
Custom error classes in JavaScript are a powerful way to provide more descriptive error information, which can be particularly useful when debugging. By extending the native Error class, you can create your own error types that can be checked against using instance of. Here’s an example:


```
class ValidationError extends Error {
  constructor(message, field) {
    super(message);
    this.name = "ValidationError";
    this.field = field;
  }
}

function validateUser(user) {
  if (!user.username) {
    throw new ValidationError("Username is required", "username");
  }
  // Additional validation checks...
}

try {
  validateUser({});
} catch (error) {
  if (error instanceof ValidationError) {
    console.error(`${error.name}: ${error.message} at ${error.field}`);
  } else {
    throw error; // Unhandled error types are re-thrown
  }
}

```

In the above code, ValidationError is a custom error class that captures additional context about the error, such as the field that failed validation. This makes it easier to handle specific error cases and provide more informative error messages.

##### Asynchronous Error Handling   
With the advent of async/await in JavaScript, handling errors in asynchronous code has become more straightforward. The await keyword allows us to write asynchronous code that looks and behaves like synchronous code. Here’s how you can handle errors in an async function:


```
async function fetchData(url) {
  try {
    const response = await fetch(url);
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    const data = await response.json();
    return data;
  } catch (error) {
    console.error('Failed to fetch data:', error);
  }
}

fetchData('https://api.example.com/data')
  .then(data => console.log(data))
  .catch(error => console.error('Error in fetchData:', error));

```

In this example, fetchData is an async function that retrieves data from a URL. If the fetch request fails or the server returns a non-200 status code, an error is thrown and caught in the catch block. This pattern allows for clean and easy-to-read asynchronous error handling.

### Error Handling in Production  
When your application moves from development to production, error handling takes on an additional layer of complexity. It’s not just about catching errors, but also about logging them appropriately, displaying user-friendly messages, and maintaining security.

##### Logging Errors   
Effective logging in production plays a crucial role in monitoring and debugging processes. To optimize this practice, it’s important to establish clear logging objectives that align with your operational goals. This involves defining the specific information that needs to be captured by the logs. Additionally, using log levels correctly is vital; it helps in distinguishing routine events from those that necessitate immediate action. Structuring your logs in an organized manner not only facilitates easier analysis but also accelerates the resolution of issues. Lastly, safeguarding your logs is imperative to ensure that they remain free of sensitive data and are maintained in a secure environment. By adhering to these best practices, you can enhance the effectiveness of your logging strategy.



##### Displaying Error Messages  
The manner in which errors are communicated to users is pivotal in shaping their experience. Employing clear and descriptive language that steers clear of technical jargon makes the message accessible and understandable. An empathetic tone is equally important; error messages should convey friendliness and assistance, rather than placing blame on the user. Additionally, a consistent design across all error messages within the application reinforces a sense of reliability and professionalism. By focusing on these aspects, you can significantly enhance user satisfaction and trust in your application.


##### Security Considerations   
Incorporating security considerations into error handling is a critical aspect of production-level software development. For instance, imagine a scenario where a user attempts to access a restricted area of a web application without proper authorization. Instead of displaying a generic error message, the system should log the attempt with enough detail for internal analysis while presenting the user with a friendly but non-specific denial message. This approach prevents the exposure of sensitive information or system vulnerabilities that could be exploited by malicious entities. Furthermore, implementing robust error handling mechanisms is crucial. These should be designed to handle exceptions gracefully without providing potential attackers with clues that could be exploited to uncover security vulnerabilities.


### Handling Common Runtime Errors   

##### Network Issues   
Network issues, while often inevitable, can be managed effectively to ensure a seamless user experience. For example, consider a user trying to submit a form on a web application. If the user’s internet connection drops, JavaScript’s navigator.onLine property can be used to detect this change in network status. The application can then respond by informing the user of the connectivity issue with a clear and user-friendly message: “Unable to connect. Please check your internet connection and try again.” To further assist the user, the application can disable features that require a network connection, thus preventing further errors and confusion.

Moreover, including a ‘Retry’ button provides users with the autonomy to initiate a new attempt once their internet connection is restored. This button should trigger a retry mechanism that re-attempts the failed network request. Implementing such a mechanism with an exponential backoff strategy is beneficial as it progressively increases the intervals between retries, thereby reducing the load on the server and enhancing the chances of successful reconnection.


```
if (!navigator.onLine) {
  displayMessage("You are offline. Please check your connection.");
} else {
  // Proceed with network request
}

```

##### Token Expiration   
Handling token expiration is a critical aspect of user authentication. To ensure a secure and uninterrupted experience, it’s important to check if the authentication token, like a JWT, is still valid before making an API call. If it’s expired, the user should be either prompted to log in again or the token should be refreshed automatically, if your system allows for it. It’s also essential to inform the user with a clear message that their session has expired and guide them to the next step, whether that’s logging in again or waiting for the token to refresh automatically. This approach helps maintain a secure environment while keeping the user experience smooth and hassle-free.



```
const token = localStorage.getItem('token');
if (isTokenExpired(token)) {
  refreshToken()
    .then(newToken => {
      localStorage.setItem('token', newToken);
      // Retry the original request with the new token
    })
    .catch(() => {
      displayMessage("Session expired. Redirecting to login page.");
      redirectToLogin();
    });
}

```

And there you have it! We’ve journeyed through the landscape of error handling in JavaScript, uncovering the tools and techniques that can transform your code from fragile to formidable. From the pesky syntax errors caught by ESLint to the more elusive logical errors that test our debugging prowess, we’ve covered a lot of ground. Remember, error handling isn’t just about fixing what’s broken; it’s about anticipating the unexpected and crafting an experience that feels seamless and thoughtful to your users. It’s about writing code that’s not only functional but also resilient and secure. 
So, I hope you take these insights, apply them to your projects, and watch as your applications stand strong against the challenges thrown their way. Keep learning, keep coding, and most importantly, keep handling those errors like the expert you’re becoming.




Error handling is a critical component of any project. It ensures that your application can gracefully manage unexpected situations, maintain its functionality, and provide a seamless user experience.

_be05b51f-98ca-4138-82b2-6e248920e6e5.jpeg

Error Handling in JavaScript Projects

Zod is a TypeScript-first schema declaration and validation library for JavaScript. It is designed to be as developer friendly as possible, with the goal of eliminating duplicative type declarations.  If you are looking for a trustworthy schema validation library in JavaScript, Zod is the one for you.  With Zod, you declare a validator once and Zod will automatically infer the static TypeScript type. It is also easy to compose simpler types into complex data structures. In this blog post, we will explore different ways to use Zod to improve the quality of your code.


Using Zod to validate your data can help you to improve the quality of your code in a number of ways:

-   It can help to prevent errors by catching type mismatches and other data validation errors.
-   It can make your code more readable and maintainable by documenting the structure of your data.
-   It can improve the performance of your code by caching frequently used validation rules.
-   It can make your code more reliable by providing a consistent way to handle validation errors.    



_   


### 1. Type/Schema Definition   
Zod is primarily used for defining and working with schemas or types in JavaScript. It allows you to create structured schemas that enforce type safety.   

```
const { z } = require("zod");

const userSchema = z.object({
  id: z.number(),
  name: z.string(),
  email: z.string().email(),
});

const user = userSchema.parse({
  id: 1,
  name: "John Doe",
  email: "john.doe@example.com",
});
```


### 2. Inferring the type of a schema
Zod is capable of inferring the type from a defined schema. This is useful for improving code clarity and avoiding repetitive type declarations.   

```
const { z } = require("zod");

const userSchema = z.object({
  id: z.number(),
  name: z.string(),
  email: z.string().email(),
});

type User = z.infer<typeof userSchema>;

const user: User = {
  id: 1,
  name: "John Doe",
  email: "john.doe@example.com",
};
```

### 3. Form/Data Validation
Zod can be used for validating form data on the client side, ensuring that the data conforms to a predefined schema.   

```
const { z } = require("zod");

const formData = {
  username: "JohnDoe",
  password: "pass123",
};

const formSchema = z.object({
  username: z.string().min(4),
  password: z.string().min(6),
});

try {
  formSchema.parse(formData);
  // Data is valid
} catch (error) {
  // Handle validation error
  console.error(error.message);
}
```

### 4. API Response Validation
You can use Zod to validate data received from APIs, ensuring it matches the expected schema.   

```
const { z } = require("zod");

const response = {
  status: "success",
  data: {
    id: 1,
    name: "John Doe",
  },
};

const responseSchema = z.object({
  status: z.literal("success"),
  data: z.object({
    id: z.number(),
    name: z.string(),
  }),
});

try {
  responseSchema.parse(response);
  // API response is valid
} catch (error) {
  // Handle validation error
  console.error(error.message);
}
```

### 5. Enum Validation
Zod allows you to define enums and validate that a value matches one of the enum options.  

```
const { z } = require("zod");

const genderEnum = z.enum(["Male", "Female", "Other"]);

const user = {
  name: "Alice",
  gender: "Female",
};

try {
  genderEnum.parse(user.gender);
  // Gender is valid
} catch (error) {
  // Handle validation error
  console.error(error.message);
}
```  


### 6. Partial
Zod's z.partial is useful when you want to validate an object with optional properties.  

```
const { z } = require("zod");

const userSchema = z.object({
  id: z.number(),
  name: z.string(),
  email: z.string().email(),
});

const partialUser = z.partial(userSchema);

const user = partialUser.parse({
  name: "John Doe",
  email: "john.doe@example.com",
});
```

### 7. Pick and Omit
Zod provides z.pick and z.omit to create new schemas by selecting or excluding specific properties from an existing schema.  

```
const { z } = require("zod");

const userSchema = z.object({
  id: z.number(),
  name: z.string(),
  email: z.string().email(),
  age: z.number(),
});

const userWithIdAndEmail = z.pick(userSchema, ["id", "email"]);

const userWithoutAge = z.omit(userSchema, ["age"]);
```


### 8. Extend
With z.extend, you can add new properties to an existing schema while keeping the existing properties.  


```

const { z } = require("zod");


const userSchema = z.object({
  id: z.number(),
  name: z.string(),
});

const extendedUserSchema = userSchema.extend({
  email: z.string().email(),
  age: z.number(),
});

```
These are  just some of the use cases of the Zod JavaScript library that I usually used in my projects. You can checkout their repository for more details [https://github.com/colinhacks/zod](https://github.com/colinhacks/zod) .




Zod is a TypeScript-first schema declaration and validation library for JavaScript. It is designed to be as developer friendly as possible, with the goal of eliminating duplicative type declarations. 

1_2W1quxolV-_crLyDtbb6Tw.jpg

8 Ways that I use Zod to Improve the Quality of My Code

In the world of PHP development, the Laravel framework stands out as one of the most popular and powerful tools for building web applications. Laravel's success is partly attributed to its adherence to various design patterns, which help developers create efficient, maintainable, and scalable code. In this blog post, we'll explore the top design patterns commonly used in the Laravel PHP community.

Design patterns are established solutions to recurring problems in software development. They provide a structured approach to solving issues and promote code reusability, maintainability, and scalability. In the context of Laravel, several design patterns are widely employed to build robust applications.

Let's dive into some of the top design patterns commonly used in the Laravel :

### 1. Singleton Pattern
The Singleton pattern ensures that a class has only one instance and provides a global point of access to that instance. In Laravel, this is often used for managing resources such as database connections or configuration settings.

```
$database = DB::connection('mysql'); // Retrieve a database connection instance (singleton).

```

### 2. Factory Pattern
The Factory pattern is used to create objects without specifying the exact class of the object that will be created. Laravel's service container leverages this pattern for dependency injection and class resolution.


```
app()->bind('MyService', MyConcreteService::class);
$service = app('MyService');

```

### 3. Observer Pattern
The Observer pattern defines a one-to-many dependency between objects, ensuring that when one object changes state, all its dependents are notified and updated automatically. Laravel's event and listener system is a prime example of this pattern, allowing you to decouple components and react to various events within the application.


```
// Defining an event
event(new UserRegistered($user));

// Creating a listener
class SendWelcomeEmail {
    public function handle(UserRegistered $event) {
        // Send a welcome email to the user.
    }
}

```

### 4. Dependency Injection
Dependency Injection is a fundamental design pattern used extensively in Laravel. It involves injecting dependencies into classes, promoting decoupling and making code more testable. Laravel's service container handles dependency injection, allowing you to easily manage and resolve dependencies.


```
class UserController {
    protected $userRepository;

    public function __construct(UserRepository $userRepository) {
        $this->userRepository = $userRepository;
    }

    public function index() {
        $users = $this->userRepository->all();
        // ...
    }
}

```

### 5. Builder Pattern
The Builder pattern is used in Laravel's query builder, allowing developers to construct complex database queries fluently. It enhances query readability and maintainability.


```
$users = DB::table('users')
            ->select('name', 'email')
            ->where('active', true)
            ->get();

```

### 6. Repository Pattern
The Repository pattern is widely used in Laravel for managing data access and abstracting database interactions. It separates data retrieval and manipulation from the rest of the application's business logic, enhancing code organization and maintainability.


```
abstract class BaseRepository
{
    /**
     * @var Model
     */
    protected $model;

    /**
     * @throws \Exception
     */
    public function __construct()
    {
        $this->makeModel();
    }

    /**
     * Configure the Model
     */
    abstract public function model(): string;

    public function makeModel()
    {
        $model = app($this->model());

        if (!$model instanceof Model) {
            throw new \Exception("Class {$this->model()} must be an instance of Illuminate\\Database\\Eloquent\\Model");
        }

        return $this->model = $model;
    }

    public function create(array $input): Model
    {
        $model = $this->model->newInstance($input);

        $model->save();

        return $model;
    }

    public function find(int $id, array $columns = ['*'])
    {
        $query = $this->model->newQuery();

        return $query->find($id, $columns);
    }
    ...
}

// Extends from BusinessLogic Repositories
class ProductRepository extends BaseRepository
{

    public function model(): string
    {
        return Product::class;
    }
    ...

}

// Inject the repository in controller
class ProductController extends AppBaseController
{
    /** @var ProductRepository $productRepository*/
    private $productRepository;

    public function __construct(ProductRepository $productRepo)
    {
        $this->productRepository = $productRepo;
    }
    ...
 }


```


### 7. Facade Pattern in Laravel
Laravel extensively uses the Facade pattern to provide a convenient and expressive interface to various services. One common example is the Auth facade for handling user authentication:


```
if (Auth::check()) {
    // User is authenticated.
}

```

### 8. Strategy Pattern in Laravel
The Strategy pattern is often used in Laravel when defining custom validation rules. You can create custom validation rules by implementing the Rule interface.


```
use Illuminate\Contracts\Validation\Rule;

class MyCustomRule implements Rule {
    public function passes($attribute, $value) {
        // Implement your validation logic here.
    }

    public function message() {
        return 'The validation failed for this attribute.';
    }
}
```

### 9. Provider Pattern in Laravel
The Provider pattern is used in Laravel for service binding and dependency injection. Laravel's service container manages the registration and resolution of classes and their dependencies.


```
// Binding a service in Laravel's service container
app()->bind('MyService', MyConcreteService::class);

// Resolving a service from the container
$service = app('MyService');

```

### 10. Pipeline Pattern
Laravel's middleware system is a perfect example of the Pipeline pattern. Middleware allows you to filter HTTP requests entering your application. Each middleware class performs a specific task in the request-response cycle.

```
namespace App\Http\Middleware;

use Closure;

class Authenticate {
    public function handle($request, Closure $next) {
        if (!auth()->check()) {
            return redirect('login');
        }

        return $next($request);
    }
}

```

### 11. Command Pattern in Laravel
Laravel's Artisan console commands make use of the Command pattern. You can create custom commands to encapsulate specific actions within your application:



```
php artisan make:command MyCustomCommand

```


Understanding these design patterns and knowing when to apply them is crucial for becoming a proficient PHP developer. Incorporating these patterns into your development practices can lead to more organized, efficient, and maintainable PHP code.

Design patterns are established solutions to recurring problems in software development. They provide a structured approach to solving issues and promote code reusability, maintainability, and scalability.

laravel-featured.png

Top Design Patterns that you can learn from Laravel 

In today's fast-evolving tech landscape, staying up to date with the latest developments in artificial intelligence (AI) is crucial for software engineers. AI has become integral to numerous industries, from healthcare to finance and beyond. One of the best ways to keep your AI skills sharp is by getting involved in open source projects. In this blog post, we'll explore some open source projects that every software engineer should consider to stay current with AI trends and innovations.

### 1. Llama 2 
It is an open source large language model provided by Microsoft and Meta. If you want to build something like ChatGPT without using OpenAI's API, then llama2 is one of the best options for you. It is free for research and commercial use.

###### Links:
[https://github.com/facebookresearch/llama](https://github.com/facebookresearch/llama)  
[https://github.com/ggerganov/llama.cpp](https://github.com/ggerganov/llama.cpp)  
[LLaMA2 with LangChain by Sam Witteveen](https://www.youtube.com/watch?v=cIRzwSXB4Rc)   
[Llama2 in LangChain by James Briggs](https://www.youtube.com/watch?v=6iHVJyX2e50)  
[How To Install LLaMA 2 Locally with TextGen WebUI by Matthew Berman](https://www.youtube.com/watch?v=k2FHUP0krqg)



### 2. GPT Engineer
"GPT Engineer is made to be easy to adapt, extend, and make your agent learn how you want your code to look. It generates an entire codebase based on a prompt"(AntonOsika, 2023). Ideally if we give proper instruction, it can be used to write a whole software. Personally, I think this will help reduce time spent on typing for a Software Engineer but I think it is not perfect yet.

###### Links:
[https://github.com/AntonOsika/gpt-engineer](https://github.com/AntonOsika/gpt-engineer)  
[How To Install GPT-Engineer by Matthew Berman](https://www.youtube.com/watch?v=ceMuK0xUtSY)  
[GPT Engineer by Dave Ebbelaar](https://www.youtube.com/watch?v=gWy-pJ2ofEM)  



### 3. Auto-GPT
Auto-GPT moves the AI industry one step closer to true artificial general intelligence. Auto-GPT is based on the language model GPT-4 and can be used in the same ways as chat bots like ChatGPT, Bard. But it automates tasks to achieve goals faster. When a user inputs a prompt, Auto-GPT will create sub-tasks for itself to process further until ultimate goal is reached. It also has features like Internet Access and Short Term Memory. Personally, I think this one is also not perfect yet. 

###### Links:
[https://github.com/Significant-Gravitas/Auto-GPT](https://github.com/Significant-Gravitas/Auto-GPT)  
[How To Use AutoGPT by Howfinity](https://www.youtube.com/watch?v=v-5AWQlTFw8)  
[Install Auto-GPT Locally by Matt Wolfe](https://www.youtube.com/watch?v=0m0AbdoFLq4)
 

### 4. MetaGPT
MetaGPT takes a one line requirement as input and outputs user stories / competitive analysis / requirements / data structures / APIs / documents, etc. Internally, MetaGPT includes product managers / architects / project managers / engineers. It provides the entire process of a software company along with carefully orchestrated SOPs.

###### Links:
[https://github.com/geekan/MetaGPT](https://github.com/geekan/MetaGPT)  
[How To Install MetaGPT by Matthew Berman](https://www.youtube.com/watch?v=uT75J_KG_aY)  
[MetaGPT Setup by Prompt Engineering](https://www.youtube.com/watch?v=nqZlTV_L6Ao)  



### 5. Stable Diffusion
Stable Diffusion is a text-to-image diffusion model and it is like the opensource alternative for Midjourney and DallE. The model behind it is relatively lightweight and runs on a GPU with at least 10GB VRAM. Personally, I think it is very good except when you generate faces with mouth open, the teeth are messed up. 

###### Links:
[https://github.com/CompVis/stable-diffusion](https://github.com/CompVis/stable-diffusion)  
[https://github.com/AUTOMATIC1111/stable-diffusion-webui](https://github.com/AUTOMATIC1111/stable-diffusion-webui)  
[https://github.com/lllyasviel/Fooocus](https://github.com/lllyasviel/Fooocus)  
[Stable Diffusion Crash Course by Freecodecamp.org](https://www.youtube.com/watch?v=dMkiOex_cKU)  
[Advanced Stable Diffusion Features in Fooocus by HolidayEffects](https://www.youtube.com/watch?v=8Rh0TsZeF6c)



### 6. YOLOv8
Even though generative models have been hot news, Artificial Intelligence is not just about Generation. YOLO, which stands for "You Only Look Once," is a popular deep learning object detection model used in computer vision tasks. YOLO models have been widely used in various applications, including autonomous vehicles, surveillance systems, robotics, and more, where real-time object detection and classification are crucial. They offer a good balance between accuracy and speed, making them valuable tools in computer vision research and practical applications. 

###### Links : 
[https://github.com/ultralytics/ultralytics](https://github.com/ultralytics/ultralytics)  
[Train Yolov8 on a custom dataset by Computer vision engineer](https://www.youtube.com/watch?v=m9fH9OWn8YM)  
[Simple YOLOv8 Object Detection with Webcam in Real-time by Nicolai Nielsen](https://www.youtube.com/watch?v=O9Jbdy5xOow)


### 7. LangChain
LangChain is a framework that makes it easier to build applications using language models. It allows applications to do two key things:
Be context-aware: This means connecting a language model to various sources of context, like prompt instructions, a few-shot examples, or relevant content, to help the model provide better responses.
Reason effectively: LangChain helps applications rely on a language model to make informed decisions, such as how to respond based on the given context and what actions to take.

###### Links:
[https://github.com/langchain-ai/langchain](https://github.com/langchain-ai/langchain)  
[https://github.com/msoedov/langcorn](https://github.com/msoedov/langcorn)  
[LangChain Crash Course by codebasics](https://www.youtube.com/watch?v=nAmC7SoVLd8)  
[LangChain Complete Tutorial by Coding Crashcourses](https://www.youtube.com/watch?v=a89vqgK-Qcs)



### 8. Hugging Face
Hugging Face is a company and open-source community that is well-known for its contributions to natural language processing (NLP) and machine learning. They provide a wide range of NLP-related resources, including pre-trained language models, libraries, and tools. Their Transformers library is widely used in the NLP community for working with transformer-based models. 

###### Links:
[https://github.com/huggingface](https://github.com/huggingface)  
[https://huggingface.co/models](https://huggingface.co/models)

### 9. Bark
Bark is a transformer-based text-to-audio model. It can generate highly realistic, multilingual speech as well as other audio - including music, background noise and simple sound effects. The model can also produce nonverbal communications like laughing, sighing and crying. 

###### Links:
[https://github.com/suno-ai/bark](https://github.com/suno-ai/bark)  
[Bark AI Full Tutorial by 1littlecoder](https://www.youtube.com/watch?v=lDeeSjShilQ)  
[Voice Cloning with Bark by Prompt Engineering](https://www.youtube.com/watch?v=o8-1hb7hFTI)  


### 10. LocalGPT
LocalGPT is an open-source initiative that allows you to converse with your documents with complete privacy. With everything running locally, you can be assured that no data ever leaves your computer. It can Seamlessly integrate a variety of open-source models and is built on top of LangChain. 

###### Links:
[https://github.com/PromtEngineer/localGPT](https://github.com/PromtEngineer/localGPT)  
[Video by Prompt Engineering to get started with it](https://www.youtube.com/watch?v=lbFmceo4D5E)  

### 11. h2oGPT
Query and summarize your documents or just chat with local private GPT LLMs using h2oGPT. It can summarize private offline database of any documents such as PDFs, Excel, Word, Images, Code, Text, MarkDown. And supports a variety of models such as LLaMa2, Falcon, WizardLM, LORA etc. Also has UI and CLI too.

###### Links:
[https://github.com/h2oai/h2ogpt](https://github.com/h2oai/h2ogpt)  
[https://evalgpt.ai/](https://evalgpt.ai/)  
[Video by Matthew Berman to get started with it](https://www.youtube.com/watch?v=H8Dx-iUY49s)  


### 12. ChatDev Communicative Agents for Software Development
ChatDev stands as a virtual software company that operates through various intelligent agents holding different roles, including Chief Executive Officer , Chief Product Officer , Chief Technology Officer , programmer , reviewer , tester , art designer . These agents form a multi-agent organizational structure and are united by a mission to "revolutionize the digital world through programming." The agents within ChatDev collaborate by participating in specialized functional seminars, including tasks such as designing, coding, testing, and documenting. The primary objective of ChatDev is to offer an easy-to-use, highly customizable and extendable framework, which is based on large language models (LLMs) and serves as an ideal scenario for studying collective intelligence. 

###### Links:
[https://github.com/OpenBMB/ChatDev](https://github.com/OpenBMB/ChatDev)   
[Video By Mathew Berman on How To Get Started With It](https://www.youtube.com/watch?v=yoAWsIfEzCw)  


In today's fast-evolving tech landscape, staying up to date with the latest developments in artificial intelligence (AI) is crucial for software engineers.

18296.jpg

12 Must-know Open-Source Projects on Artificial Intelligence (As a Competitive Software Engineer)

As a React developer, you need to be familiar with a wide variety of tools, libraries, and frameworks that can help you build better web applications. In this post, we'll explore four key areas: build tools, state management, testing, and full-stack development.

### Build Tools
Build tools are essential for modern web development, as they help automate tasks like bundling, transpiling, and optimizing your code. Here are some of the most popular build tools for React developers:

##### [Webpack](https://webpack.js.org/)

Webpack is a popular bundler that can handle bundling and optimizing your code for production. It allows you to use a wide variety of plugins and loaders to customize your build process, and has a large and active community that contributes to its development.

##### [Vite](https://vitejs.dev/)

Vite is a relatively new build tool that's been gaining popularity in the React community. It's known for its fast build times and live reloading, which make it a great choice for development workflows.

##### [Parcel](https://parceljs.org/)

Parcel is a zero-configuration bundler that can handle bundling and optimizing your code with minimal setup. It can automatically detect your dependencies and configure your build process accordingly, making it a good choice for small to medium-sized projects.

##### [Rollup](https://rollupjs.org/)

Rollup is a bundler that's optimized for building libraries and smaller-scale applications. It can produce smaller and faster builds than other bundlers like Webpack, and has a strong focus on tree-shaking and code splitting to reduce the size of your bundles.

### State Management
State management is a critical part of building complex React applications, as it allows you to manage the state of your application and ensure that different components can communicate with each other. Here are some popular state management libraries that you should be familiar with:

##### [Redux](https://redux.js.org/)

Redux is a popular library that provides a centralized store for managing the state of your application. It uses a predictable state container and a unidirectional data flow to ensure that your application's state is easy to reason about, and has a wide variety of plugins and integrations available.

##### [Context API](https://react.dev/learn/passing-data-deeply-with-context)

The React Context API is a built-in state management solution that allows you to pass data down through the component tree without having to use props. It's lightweight and easy to use, but can be less powerful than dedicated state management libraries.

##### [Recoil](https://recoiljs.org/)

Recoil is a new state management library developed by Facebook that uses a similar API to Redux but with a focus on flexibility and performance. It allows you to manage the state of your application in an intuitive way, and has features like asynchronous selectors and snapshots that can make it easier to debug and optimize your code.

##### [Zustand](https://github.com/pmndrs/zustand)

Zustand is a relatively new state management library for React that provides a simple and scalable way to manage state in your application. It's built on top of the React Context API, but adds a number of useful features and optimizations. One of the key benefits of Zustand is its simplicity. It provides a small and intuitive API for defining and updating state, and makes it easy to create and manage multiple stores. It also supports both synchronous and asynchronous actions, and provides built-in support for immutability and selector functions.

##### [Jotai](https://jotai.org/)

Jotai is a state management library for React that uses atoms and selectors to manage and manipulate state. It is a simple and lightweight library that aims to provide an easy-to-use and declarative way to manage state in React applications.

The core concept of Jotai is the "atom", which is a unit of state that can be read and updated by components. Atoms are defined using the atom function, which takes an initial value as its argument. Components can then access the atom's value using the useAtom hook, which returns the current value and a setter function to update the value.

Selectors are another important concept in Jotai, which allow
you to derive state from other atoms or selectors. Selectors are defined using the selector function, which takes one or more atoms or selectors as input, and a function that returns the derived state. Components can then access the derived state using the useAtom hook, just like with atoms.


##### [React Query](https://tanstack.com/query/v3/)

While React Query is primarily designed for managing asynchronous data fetching and caching, it can also be used to manage local state in some cases. However, it's important to note that React Query is not a true state management library like Redux or MobX, and is not optimized for handling complex local state.


### Data Fetching
Data fetching is a critical aspect of modern web development, particularly in the context of single-page applications (SPAs) built with ReactJS. Whether you're building a simple blog or a complex enterprise application, fetching and displaying data is a fundamental part of the user experience. 

##### [Axios](https://axios-http.com/docs/intro)
Axios is a popular and widely-used library for making HTTP requests in JavaScript. It can be used both on the client and server side and has a simple and intuitive API that makes it easy to send and handle requests.

##### [Fetch API](https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API)

The Fetch API is a modern, built-in API for making HTTP requests in JavaScript. It provides a simple and flexible interface for sending requests and handling responses, and can be used both on the client and server side.

##### [React Query](https://tanstack.com/query/v3/) 

React Query is a powerful and flexible library for handling data fetching and caching in React applications. It provides a variety of hooks and utilities for making API requests, handling loading and error states, and caching responses, making it easy to build efficient and responsive applications.

 ##### [SWR](https://swr.vercel.app/)
 
SWR (pronounced "swear") is a lightweight and fast library for handling data fetching and caching in React applications. It provides a variety of hooks and utilities for making API requests, handling loading and error states, and caching responses, and is designed to work seamlessly with the React rendering lifecycle.

##### [Apollo Client](https://www.apollographql.com/docs/react/)

Apollo Client is a powerful and flexible library for handling data fetching and caching in GraphQL-based React applications. It provides a variety of hooks and utilities for making GraphQL queries, handling loading and error states, and caching responses, and can be used with a variety of GraphQL servers and APIs.


### Testing
Testing is an essential part of building reliable and high-quality web applications. Here are some popular testing frameworks and tools that you should be familiar with:

 ##### [Jest](https://jestjs.io/) 
 
Jest is a popular testing framework developed by Facebook that can handle unit tests, integration tests, and snapshot tests for React components. It has a simple and intuitive API, and comes with built-in support for features like mocking and code coverage.

##### [React Testing Library](https://testing-library.com/docs/react-testing-library/intro/)

React Testing Library is a lightweight testing utility that encourages testing your React components in a way that simulates how your users will interact with your app. It has a simple and intuitive API, and is designed to encourage best practices.


 ##### [Cypress](https://www.cypress.io/)
 
 
Cypress is an end-to-end testing framework that allows you to write and run automated tests that simulate real user behavior. It has a simple and intuitive API, and comes with a variety of powerful features like time travel debugging, network stubbing, and automatic waiting for DOM elements.


In conclusion, as a React developer, being familiar with these tools, libraries, and frameworks can help you build better and more efficient web applications. Whether you're working on the client or server side, testing your code, or managing state, these tools can help streamline your development process and make your code more reliable and maintainable.




As a React developer, you need to be familiar with a wide variety of tools, libraries, and frameworks that can help you build better web applications. 

All Articles

Browse All Posts