For example, local-first. The app is just -- Jerod Santo: Fast. James Long: ...fast by default. I mean, it's no question. That's the first thing that everybody always says when they try the app. They feel it. They feel their data sitting right there on the hard disk. And I don't have to think about it. I can run 100 queries straight from the frontend, not even in the backend. So there is kind of a frontend and a server process running, but that process is always a local process. I can run queries, send them to the server, and I can fire off 100 right from the frontend, and you don't feel that at all. It's one of those things that just changed the whole experience of the app. There's no - you do a bulk edit of your 3,000 transactions in an account, because you're doing something crazy and you're really restructuring things, and you bulk-edit things to add a note to these 3,000 transactions, so you select them all and type "archived". It happens in 200 milliseconds. Whereas you go to any other app and there's this huge cliff of anything that's outside of the ordinary workflow that they've specifically manually optimized - suddenly it has to span their five database clusters, and it takes you'll see the loading spinne

Vite's job is to get your source modules into a form that can run in the browser as fast as possible. To that end, we recommend separating static analysis checks from Vite's transform pipeline.

Vite uses esbuild to transpile TypeScript into JavaScript which is about 20~30x faster than vanilla tsc, and HMR updates can reflect in the browser in under 50ms.

Above: the time to do a production bundle

Serializing the data with a function specialized to your data shape can be more than 10x compared with JSON.stringify.

This still would not eliminate all delay, but I think this could be faster (no render blocking), and cleaner than having inline scripts scattered all over the parent document.

it's much faster—the stack frame does not have to be carried along the "thrown symbol", and no object is created. Lightweight nonlinear flow control.

You can return the record directly from the UPDATE, which is much faster than calling an additional SELECT statement. Use RETURN QUERY and UPDATE with a RETURNING clause.

You could also use the NodeIterator API, but TreeWalker is faster

All those 'modern' and 'super-modern' querySelectorAll("*") need to process all nodes and do string comparisons on every node.

the fastest solution because the main workload is done by the Browser Engine NOT the JavaScript Engine

The template language's restrictions compared to JavaScript/JSX-built views are part of Svelte's performance story. It's able to optimize things ahead of time that are impossible with dynamic code because of the constraints. Here's a couple tweets from the author about that

Because Jamstack projects don’t rely on server-side code, they can be distributed instead of living on a single server. Serving directly from a CDN unlocks speeds and performance that can’t be beat. The more of your app you can push to the edge, the better the user experience.

Better PerformanceWhy wait for pages to build on the fly when you can generate them at deploy time? When it comes to minimizing the time to first byte, nothing beats pre-built files served over a CDN.

It's fast. The Dart VM is highly optimized, and getting faster all the time (for the latest performance numbers, see perf.md). It's much faster than Ruby, and close to par with C++.

Virtual DOM is valuable because it allows you to build apps without thinking about state transitions, with performance that is generally good enough

In the vast majority of cases there’s nothing wrong about wasted renders. They take so little resources that it is simply undetectable for a human eye. In fact, comparing each component’s props to its previous props shallowly (I’m not even talking about deeply) can be more resource extensive then simply re-rendering the entire subtree.

If you need to call the function repeatedly, this is much, much faster than using eval.

For example, to search for text occurrences, I used ack-grep. Later on, I found that there is a faster approach using ag. Then, there is an even faster alternative called ripgrep.

Speed example -- over 829 files, the "find -exec" method took 26 seconds while the "find -print0 | xargs --null" method tool 0.7 seconds. Significant difference.

Building blocks that ensure performance It takes a lot of time and effort to build a great website. AMP components are already optimized for the best performance.

uses a pre-clone step to seed the project with a recent archive of the repository. This is done for several reasons: It speeds up builds because a 800 MB download only takes seconds, as opposed to a full Git clone.

GIT_DEPTH: '1' helps a little bit but we could speed up our pipelines massively for jobs that only rely on an image that is the sole dependency to run the job.

“I feel like I’m just talking HTTP at last, with nothing in the middle. Falcon seems like the requests of backend.”