Something found next to a handle

Best practices for exceptions

Proper exception handling is essential for application reliability. You can intentionally handle expected exceptions to prevent your app from crashing. However, a crashed app is more reliable and diagnosable than an app with undefined behavior.

This article describes best practices for handling and creating exceptions.

Handling exceptions

The following best practices concern how you handle exceptions:

Use try/catch/finally blocks to recover from errors or release resources

For code that can potentially generate an exception, and when your app can recover from that exception, use / blocks around the code. In blocks, always order exceptions from the most derived to the least derived. (All exceptions derive from the Exception class. More derived exceptions aren't handled by a clause that's preceded by a clause for a base exception class.) When your code can't recover from an exception, don't catch that exception. Enable methods further up the call stack to recover if possible.

Clean up resources that are allocated with either statements or blocks. Prefer statements to automatically clean up resources when exceptions are thrown. Use blocks to cle

How much traffic can a pre-rendered Next.js site really handle?

I've often said things like "A pre-rendered site can easily serve hundreds of concurrent users", because, well, I've never seen one fail.

But how many can it really handle? Could my site actually handle a traffic surge from landing on something like the Hacker News frontpage? How does it compare to server-side rendering? And is it actually worth jumping through hoops to avoid SSR?

I looked around for hard data on Next.js performance, but solid numbers were surprisingly hard to find. So, I ran some tests on my own site, and the results weren't what I expected. And in perfect timing, my article on Google Translate interfering with Reacthit the Hacker News frontpage the very next day.

Right after I discovered (spoiler alert) my site probably couldn't handle it.

A pre-rendered site on a VPS

The first thing I wanted to find out was whether my site could handle a surge in visitors from something like hitting the frontpage of Hacker News.

To test this, I wrote a basic k6 load testing script to measure the max requests per second my server could handle. The script was as simple as

How to handle an Unhandled Promise Rejection in JavaScript

Let's look at what you should do when there is an "unhandled promise rejection".

#What is a Promise?

It is similar to making a promise in real life, where you promise to do something in the future. A promise always has two outcomes: you either do it by keeping your Promise or you do not.

A promise object has two properties: state and result. The state can be pending, fulfilled, or rejected; the result can be undefined or the value of the fulfilled or rejected state.

In clear terms, the promise state is initially pending with a result of undefined; when the Promise's condition is true, the state is fulfilled and has a result with the value of resolve(value); otherwise, when the condition fails, it has an error value of reject (error).

For example, the code block below is a Promise that checks a condition. If the condition is true it otherwise, it .

const myPromise =newPromise((resolve, reject)=>{

let cms ="Hygraph";

if(cms ==="Hygraph"){

resolve("Success: The promise has successfully resolved!");

}else{

reject("Failure: The promise has failed!");

Error Handling

Error Handling refers to how Express catches and processes errors that occur both synchronously and asynchronously. Express comes with a default error handler so you don’t need to write your own to get started.

Catching Errors

It’s important to ensure that Communicate catches all errors that occur while running route handlers and middleware.

Errors that occur in synchronous code inside route handlers and middleware require no extra operate. If synchronous code throws an error, then Express will seize and process it. For example:

For errors returned from asynchronous functions invoked by route handlers and middleware, you must pass them to the function, where Show will catch and process them. For example:

Starting with Express 5, route handlers and middleware that return a Promise will contact automatically when they reject or throw an error. For example:

If throws an error or rejects, will be called with either the thrown error or the rejected value. If no rejected value is provided, will be called with a default Error object provided by the Communicate router.

If you pass anything to the function (except the string ), Express regards the current request as being a