It's typically taken for granted that better performance must require higher complexity. But I've often had the experience that making some component of a system faster allows the system as a whole to be simpler

The latest SQLite 3.8.7 alpha version is 50% faster than the 3.7.17 release from 16 months ago. [...] This is 50% faster at the low-level grunt work of moving bits on and off disk and search b-trees. We have achieved this by incorporating hundreds of micro-optimizations. Each micro-optimization might improve the performance by as little as 0.05%. If we get one that improves performance by 0.25%, that is considered a huge win. Each of these optimizations is unmeasurable on a real-world system (we have to use cachegrind to get repeatable run-times) but if you do enough of them, they add up.

fun, fairness, and challenge

My students do not arrive in the gym thinking about how their performance will be evaluated.

They will demonstrate the art of the catch. Their art of the catch.

there are thousands of pieces that I miss

“performance'' because I teach physical education

Edge computing is an emerging new trend in cloud data storage that improves how we access and process data online. Businesses dealing with high-frequency transactions like banks, social media companies, and online gaming operators may benefit from edge computing.

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.

All of these approaches use a comparison technique called "shallow equality". This means checking every individual field in two different objects, and seeing if any of the contents of the objects are a different value. In other words, obj1.a === obj2.a && obj1.b === obj2.b && ......... This is typically a fast process, because === comparisons are very simple for the JS engine to do. So, these three approaches do the equivalent of const shouldRender = !shallowEqual(newProps, prevProps).

When trying to improve software performance in general, there are two basic approaches: 1) do the same work faster, and 2) do less work. Optimizing React rendering is primarily about doing less work by skipping rendering components when appropriate.

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.

Anita: So, you said you wanted to start off by singing a song?Billy: Yeah, well I’ll sing a song. [Singing] “Well I guess you wondering where I'd been. I searched to find the love within. In my world only you make me do for love, girl, what I would not do. My friends wonder what is wrong with me, but I'm in a daze." Alright. That's it.

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.

The digestive consequences of forage consumption are determined by plant forage quality and animal digestive and detoxification abilities. This interaction, in turn, affects the nutrients and energy available for animal growth and maintenance.

“I’m not a musician. I don’t mean that in a derogatory way. But I mean, I wasted a lot of my life playing instruments, which was foolish,” O’Rourke told the newsletter Tone Glow in an interview published in May 2020. “I have no interest in anything being a vessel for expressing something . . . I always like to say, ‘I do stuff.’ ”

Optimization in this case is nothing crazy, just something I neglected while designing the framework.

The dynamic maximum strength of the calves is a basic prerequisite for short sprints and should be regarded as a performance reserve.

If a UTF8-encoded Ruby string contains unicode characters, then indexing into that string becomes O(N). This can lead to very bad performance in string_end_with_semicolon?, as it would have to scan through the whole buffer for every single file. This commit fixes it to use UTF32 if there are any non-ascii characters in the files.

What is the point of avoiding the semicolon in concat_javascript_sources

   (intermediate value)(...) is not a function
       at something.source.js:1

   ({
     // other.js
   })()
   (function() {
     // something.js
   })();

And no need to walk backwards through all these strings which is surprisingly inefficient in Ruby.

Since the common problem with concatenating JavaScript files is the lack of semicolons, automatically adding one (that, like Sam said, will then be removed by the minifier if it's unnecessary) seems on the surface to be a perfectly fine speed optimization.

reducing it down to one call significantly speeds up the operation.

I feel like the walk in string_end_with_semicolon? is unnecessarily expensive when having an extra semicolon doesn't invalidate any JavaScript syntax.

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

One of my favorite knee-friendly strength training exercises is the half-squat, half-deadlift.

The alternative was to have multiple scripts or stylesheet links on one page, which would trigger multiple HTTP requests. Multiple requests mean multiple connection handshakes for each link “hey, I want some data”, “okay, I have the data”, “alright I heard that you have the data, give it to me” (SYN, ACK, SYNACK). Even once the connection is created there is a feature of TCP called TCP slow start that will throttle the speed of the data being sent at the beginning of a request to a slower speed than the end of the request. All of this means transferring one large request is faster than transferring the same data split up into several smaller requests.

why a company like Facebook invests so much research and engineering into the network performance of things as seemingly trivial as notifications.

Nearly 10,000 fans watched her 30-minute performance on Pitchfork’s Instagram, for free.

Just saying “snaps are slow” is not helpful to anyone. Because frankly, they’re not. Some might be, but others aren’t. Using blanket statements which are wildly inaccurate will not help your argument. Bring data to the discussion, not hearsay or hyperbole.

I don’t find the software slow, I find the startup time for snap packages when the start for the first time on a session slow, but that has been improved, and it’s public that the snapcraft team has been working hard to improve that.

People think that fighters fight best when they are angry, that singers, actors and musicians perform best when they are high on emotions. This cannot be further from the truth. Studies show that in high-stress situations, we perform when we separate ourselves from our emotions. Like how a cup is only useful when it’s empty, it is only when we empty ourselves that we can become a conduit for our art, transcend our mortal shell, and perform at the highest levels.

it can be difficult or verbose to accomplish some things like animations in React, especially without libraries, and high-performance React animation libraries often bail out of its rendering cycle to manipulate the DOM directly.

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.

Psychologists have only seriously begun analyzing self-talk in the last couple of decades, and here’s what we know:1) Positive self-talk improves performance in most sports.2) Questions like “Will I do this?” produce better results than statements like “I will do this.”3) Using “we” in self-talk is better than using “I.”4) Talking about yourself in third person is more effective than talking in first person.5) Both motivational (“I will do this!“) and instructional (“See the target…straighten elbows…lock onto target…“) self-talk seems to be effective in enhancing performance.

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++.

Preserving user privacy is difficult when detectingmore nuanced forms of censorshipSome forms of softcensorship might involve intentional performance degrada-tion or content manipulation. Detecting this type of behav-ior would require comparing performance or content acrossgroups of users, but such a comparison also implies thateach user must reveal their browsing history.

“But nobody sees us,”

We could freeze the objects in the model but don't for efficiency. (The benefits of an immutable-equivalent data structure will be documented in vtree or blog post at some point)

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.

In some frameworks you may see recommendations to avoid inline event handlers for performance reasons, particularly inside loops. That advice doesn't apply to Svelte — the compiler will always do the right thing, whichever form you choose.

One problem—not a fatal one, but still an issue with any virtual DOM—is that embedding SVGs directly into your app can be a resource hog. No matter how much you compress, no matter how logical and streamlined your components, if you need to load up hundreds of very-complex SVGs, React will need to track all of their nodes, and updating them becomes a chore.

If those comments are loaded outside of the blog_post association, then attempting to reference the blog_post association from within each comment will result in N blog_posts table queries even if they all belong to the same BlogPost!

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.

We don't have a performance group. Ensuring GitLab is performant is the responsibility of all groups.

Although it can minimize the overhead of third-party tags, it also makes it trivial for anyone with credentials to add costly tags.

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

How do you leverage browser cache when Google’s very own Analytics.js has it’s expiry time set to 2 hours? How do you minimize DNS requests when Google advices you to copy their tracking code, linking to an externally hosted Javascript file?If that isn’t bad enough already, Google’s advice is to avoid hosting the JavaScript file locally. And why? To ensure you get access to new features and product updates.

Why should I host analytics.js locally?The Complete Analytics Optimization Suite for WordPress gives you the best of both worlds. After activation it automagically downloads the latest version of analytics.js from Google’s servers, places the necessary tracking code in your WordPress theme’s header and keeps the local Javascript file up-to-date using an adjusted version of Matthew Horne’s update analytics script and wp_cron(). This way you can minimize DNS requests, leverage browser cache, track your visitors and still follow Google’s recommendation to use the latest features and product updates.

I would like to make an appeal to core developers: all design decisions involving involuntary session creation MUST be made with a great caution. In case of a high-load project, avoiding to create a session for non-authenticated users is a vital strategy with a critical influence on application performance. It doesn't really make a big difference, whether you use a database backend, or Redis, or whatever else; eventually, your load would be high enough, and scaling further would not help anymore, so that either network access to the session backend or its “INSERT” performance would become a bottleneck. In my case, it's an application with 20-25 ms response time under a 20000-30000 RPM load. Having to create a session for an each session-less request would be critical enough to decide not to upgrade Django, or to fork and rewrite the corresponding components.

Performance Benchmarking What it is: Testing a system under certain reproducible conditions Why do it: To establish a baseline which can be tested against regularly to ensure a system’s performance remains constant, or validate improvements as a result of change Answers the question: “How is my app performing, and how does that compare with the past?”

Ag was 34x faster

Files are mmap()ed instead of read into a buffer.

when we ran it natively on the source machine (i.e. not Dockerized, which reduces performance for all the tools by ~40%)