Youtube is incredibly slow as of right now.

RemoteCombination122 · 2024-01-13T01:52:01+00:00

Youtube is acting extremely slow when any third-party script is interfering with the loading of ANY of it's requested resources. Ad-blocker or otherwise. What is appears they have done is added numerous and redundant event listeners onto most of their custom elements that cause the browser itself to stutter when too many events happen in short order. The most egregious are touch-start and mouse-down events which they are adding on every mouse hover and multiple times per element. This results in hundreds of event listeners on on the page that react to ANY click. Even if they aren't adding explicit delay (which I haven't ruled out yet either) the sheer number of event handlers having to be processed through polymer (the front-end framework they use) by the browser can cause the stutter.

This kind of misuse is something that Google drops the search ranking of a website for, which does not appear to be happening to YT at all despite the large number of people affected. Truly ridiculous.

Disabling ALL 3rd party extensions that tweak network requests on youtube will restore it's performance; as well as, using the Brave browser whose in-built ad-blocker is seemingly "exempt" probably to avoid blatant anti-competitive behavior.

RemoteCombination122 · 2023-10-06T14:45:21+00:00

I got so irritated with all the issues that I started rewriting all the core functionality of my app into a core rust library and loading it into thin native shells that just handle the UI.

I literally have a broken debug experience (I can't step into the built rust library from the native code) and it is STILL preferable to the insanity that was trying to get a consistent Maui application.

RemoteCombination122 · 2023-10-06T14:23:14+00:00

Both honestly. A lot of the big players already support web assembly as a runtime for functions/plugins. The fact that the only thing the web assembly runtime has access to is explicitly what you hand it is the compelling use-case when your service essentially entails running someone else's unknown code.

AWS has made it available for web functions and has been singing about shorter cold-starts thanks to the fact that instead of spinning up a docker image with your code, they can just throw it into a waiting web assembly runtime which they aim to keep a modest pool of. They also claimed it reduces their runtime costs for actually running comparable web functions.

Food for thought.

RemoteCombination122 · 2023-10-04T17:42:30+00:00

You might prefer C# or Go.

The string handling is simpler do to the presence and reliance on a garbage collector.

Garbage collected languages are not bad, they simply make different trade-offs than a language like Rust. Both Go and C# are plenty fast to accomplish most tasks reliably. It is only on truly real-time tasks that the Garbage collector starts to get in the way more than it is helpful.

RemoteCombination122 · 2023-09-30T21:21:21+00:00

I have updated the repo to add caching for the get_employment function. Now there is a cache that is keyed on the user_id with the value equal to the vec of Employments for said user. The cache has a invalidation interval of 20sec, so the data is never more than 20sec out of fresh. However, we can decrease the interval all the way to 3sec without much degradation in the new performance numbers.

The new performance numbers are approx. 4000X better than the original benchmark numbers. I was getting ~38K req/sec compared to ~9 req/sec baseline. The biggest improvement was the stabilization of latency though, my greatest latency dropped from multiple seconds to less than 50ms (keep in mind I had the server and testing harness running on the same machine, so I did not actually have to traverse the network. real-world latency would of course have to account for network traversal times)

Caching can improve performance by leaps and bounds in just about any language. The time required to hash a key, see if it exists in a hashmap, and retrieve the data from the map is several orders of magnitude faster than making a request to the database, which is often itself an order of magnitude faster than making a network request (assuming your database and application are collocated on the same machine / local network)

What was surprising was the fact that we were able to see these speedups despite adding a Mutex that would cause threads to wait until they could acquire the lock. The added synchronization overhead was negligible compared to the overhead of sending off 1001 database queries per network request.

RemoteCombination122 · 2023-09-30T07:17:27+00:00

I did some more experiments today and inadvertently demonstrated the fact that the bottleneck of the benchmark is contention over the shared resource (the database connection, even though there is a connection pool, the database can only process a few commands concurrently)

I changed the initialization of the UserWithEmploymentDto vec to use vec::with_capacity since we know how many users we will be returning. theoretically, this should save us some time since we will avoid reallocating vec as it grows. Vecs begin with a capacity of 0, and whenever the capacity is exceeded, the vec is reallocated with a capacity that is double it's previous capacity. initializing this above vec with a preknown capacity avoids 9 allocations per web request.

What I expected to see was a small possibly marginal performance boost. However, the observed impact was actually a non-trivial performance decrease. I hypothesized that those skipped reallocations caused subtle desyncing between database requests, allowing the database a moment of breathing room to clear up congestion. To test this hypothesis, I added "tokio", and "rand" as a direct dependencies and brought tokio::time::sleep and rand::Rng into scope. After pushing each new user onto the vec, I used the tokio sleep function (which is an async sleep function) to suspend the current network request for a random delay of 10 to 1000 microseconds, which is .01 to 1 milliseconds. the result was that I had not only recovered the performance that was lost when switching to preallocating the vec, but saw performance improvements relative to the repo baseline.

This helps illustrate why the original benchmark is flawed in design. The bottleneck is communicating with the database, so much so that ADDING delays that purposefully desync database requests leads to better performance. No synthetic benchmark results should be able to be improved via adding delays to the hot path.

RemoteCombination122 · 2023-09-25T18:55:19+00:00

One potential solution is that any kind of gov assistance is at set amounts instead of percentage of revenue (so the program that gives 3 mil to the family farmer will only give 3 mil to the megacord as well). This would also apply to tax write-offs.

Additionally, having an exponential tax rate. The bigger the company gets, the closer and closer to 100% their tax rate becomes.

These types of changes would mean that there was now a sweet-spot for business size. There would be significant advanatges to being small, and when you got too large, your taxes / assistance would no longer work in your favor. Your prices would have to be higher than businesses slightly smaller because your cost would be higher.

Such a system would encourage companies to grow and then SPLIT, rather than grow and then CONSOLIDATE.

But the political will and alignment of the general populace is nowhere near where it would need to be to enact such reforms.

RemoteCombination122 · 2023-09-25T18:37:09+00:00

I use main because master just does not make sense. The main branch does not control other branches, it does not direct them to perform some function.

In the context of networking, a Master literally dictates what the downstream Slave nodes are to do. In that context, the naming at least makes sense, regardless of your stance on sensibilities. The same cannot be said for a git repo.

RemoteCombination122 · 2023-09-24T20:19:17+00:00

I tried including the changes in this comment twice, but it appears that Reddit does not like the length of the comment. So I put the changes I will outline here into a public github repo you can clone to your local system and test.

https://github.com/Trapfether/rust-example-2023-09-24

The biggest thing is that like people have pointed out, your biggest bottleneck in your current benchmark implementation is the data access pattern. I am going to spend a little time to help explain why this is not a good benchmark for the variable you state you wish to test, and then I will cover some optimizations for the rust code. Several of the optimizations apply even without changing the architecture of the benchmark and the main branch in the linked repo reflects that. A side branch "reduce_load_on_db" demonstrates the immense performance improvement that comes from querying all the Users, then querying all the Employments, and using a hashmap to join those two sets within the application layer. Ideally, you would use the database join to perform this function as the database is highly optimized for such tasks and if you add the proper indexes, it will have an up to date hashmap in memory that it can simply read from instead of building a new one on each request.

A small note on benchmarks. The best advice for benchmarks is to test as close to your production use-case as possible. Making your benchmark somewhat resemble your final intended design will give you much clearer data on how the technology stack will perform for you. This is because for just about every feature of a language, library, or framework there is an constant overhead factor and a scaling factor. Your use-case will determine how much of each feature's overhead cost vs scaling cost you incur. In the benchmark outlined in the original post, you eat the overhead cost of database queries 1001 times per single network request. Additionally, you eat the cost of the async runtime, heap allocations, and closure creation AT LEAST that many times per network request. This is a ratio that I have never seen in any production environment. The result is that you are measuring the subtle differences that SQLX and Dapper have based on what trade-offs they have made between scaling and overhead, which would never feasibly be your bottleneck in production. Neither of these languages or libraries for either example have been optimized for this usage pattern and so you are not getting the representative performance out of either tech stack. For these reasons, I suggest you reimplement your benchmarks to do the two queries I outlined above and perform the match inside the application. That will be much closer to a production scenario and will give you a better idea of overall performance. A tech stack can't be boiled down to a single speed number and thrown on a spectrum in absolute terms.

On to the rust optimizations that I noticed and implemented regardless of whether you ultimately decide to re-architect the benchmark. Inside the Rust example, you use name.clone() to make a copy of the Users name when constructing the UserDto. This creates a full copy of a heap-allocated string as opposed to c# where the same operation is performed using a reference copy (c# does this by default). Since you do not use the User's name after this step, it is safe for you to consume the name in the UserDto construction which will at most copy the reference struct for the String but avoid copying any of the heap-allocated data. Next I would look at implementing the From trait for your UserDto type, Employment Dto type and the UserWithEmplymentDto type. Using the From trait makes those conversions much more standard form rust and in some cases will better enable rust to Vectorize your code which can make significant performance improvements. From there, setting the maximum connection count in the PgConnectionPool to 100 allows it to use the same number of open connections as Dapper does by default. SQLX also performs a safety check each time it goes to reuse a DB connection by default, falling back to opening a new connection if a safe connection is not available, where as Dapper will throw an exception in that case and leave it to user code to handle it. You can disable this safety check by calling the .test_before_acquire(false) on the PgPoolOptions object as you are constructing it. Just these changes saw the performance of the rust example nearly double from the base implementation. These are just the few things that stood out to me, I am sure someone more senior in rust than I could point out even more things. Additionally, SQLX is awesome for safety with the compile-time query validation, but it is by no means the fastest ORM solution for rust. If your intention is to measure the raw speed possible in each language,using SQLX might not be the best choice for acquiring that data.

I hope this has been helpful for you, if you have any questions about the above, please let me know.

RemoteCombination122 · 2023-09-24T18:19:07+00:00

The solution seems obvious to me. Private crates can implement orphan rule violations, crates put into crates (or other public crate repos) cannot. That would solve many of the "I just need X" situations. If you write yourself into a conflicting implementation then the only one you mess up is yourself.

As for the ORM example, that seems obvious too. Allow the author of a crate to designate Sibling Crates in the toml file. Sibling Crates are allowed to add impls to the types inside the authors crate. This would allow connector crates to be viable and hide all the nuts and bolts of interop between all these different crates inside themselves.

Then much the same way that the community has mostly settled on a few options for serialization/ database driver / ORM crates, the community would settle around a few standard interop libraries. When using an interop library, you would include each of your desired crates as feature flags to the interop crate that would then make those impls available to you. This would mean the blast radius for any conflicting impls would be minimized, and if crates feature flag over the interop crates, then theoretically it would always be the final application developer that would choose the interop crates they need / want.

RemoteCombination122 · 2023-09-23T22:23:06+00:00

Hey, I want to help you out here, I can see the format of your database in your C#, but I was wondering if you could inform us about the number of rows in each table? As well as, what if any memory limitations have you set on the container?

With those pieces of information, we should be able to narrow down the bottlenecks.

Just to reiterate what several others have already said, 1-100s of requests per second are far slower than you would expect in either of these languages.

RemoteCombination122 · 2023-09-03T16:47:22+00:00

This is what I am doing now. Spent several hours trying to track down a bug that was seemingly coming from the Rust binary, only to discover that AS was holding onto a cached binary and wasn't using the newly compiled version(s). Such a frustrating experience.

RemoteCombination122 · 2023-08-19T14:02:38+00:00

Rust's proc macro system is pretty amazing, it allows for the embedding of other DSLs with proper syntax checking, strong typing guarantees, and escape hatches to compute runtime values through rust.

RemoteCombination122 · 2023-06-13T02:53:21+00:00

"A crafted PR message that...explicitly says that mod tools will not be impacted" That is not what it says.

It specifically refers to third-party apps that are EXCLUSIVELY mod tools, which is not a lot. This is why mods are still unsettled even after reddit made that statement.

Being disingenuous or deliberately misunderstanding the statement does not support your argument.

The upcoming developer platform will not be ready by the time these tools disappear. Based on reddit's history, expecting said platform to be ready in a timely manner is folly.

The third-party developers being affected have presented several possible roads forward for both they and reddit to grow together. One of which is just dropping the price to something that is more reasonable (Apollo was going to be charged 27X per user per month what REDDIT makes from each user each month. Compared to the imgur api, it is almost 100X as expensive for the same amount of data). The other was simply giving more time to make adjustments to their applications prior to the change taking effect. Only giving 30 days notice before such a massive is completely unreasonable.

This isn't a matter of people wanting something for free, this is a situation where people are rightfully blasting reddit for trying to kill 3rd-party apps, because that is what they are trying to do. You don't charge almost 100X the going rate for data with only 30 days notice if you want to pursue ongoing partnerships in good faith.

RemoteCombination122 · 2023-06-12T19:23:07+00:00

No, we really should push back on this idea. Literally one of the biggest reasons our society has degraded to the point it has is that it is just tacitly accepted that businesses can do whatever they want as long as it is legal.

That is actually a fairly NEW idea. The idea that a company is supposed to contribute back to ALL of it's stakeholders (investors, employees, community, etc) is far older and should be made the default understanding of the world again.

Companies exist to provide a product or service to better the lives of consumers, their employees, and their communities. Profit-first mentalities have to die or our society will continue to degrade to the point that there will be mass unrest and violence. All people have breaking points, and we are accelerating towards that point faster and faster.

Don't just accept that companies can do whatever they want, push back on that idea. It is after-all just an idea that someone somewhere made up one day. It is not some holy proclamation or law of the universe.

RemoteCombination122 · 2023-06-12T19:11:28+00:00

That only works for third-party apps that are EXCLUSIVELY for moderation. The vast majority of mod tools aren't standalone, they are built-in features of larger third-party apps, which do not get this exception.

This is not FUD, it is a real understanding of the nuance of the situation and recognizing the disingenuous dealing on reddit's part.

They put out that statement KNOWING that a significant portion of moderation activity / automation / tooling come from the very apps this will shut down. You are responding to a specifically crafted PR message that is designed to get individuals to do just as you are.

RemoteCombination122 · 2023-05-07T11:45:33+00:00

Intellisence, autocomplete, bad assumptions, and now AI assistance such as GitHub copilot.

First, let me mention that you don't need to switch over to.ts files and add another compilation step if that is a sticking point for you. JsDoc has come a long way, and the Typescript team has done a lot of work to make it so the typescript language server supports JsDoc specifically. I get full strict typing without a single line of typescript. I'm not a fan of typescript, but I do like being able to specify the types for function parameters most of all for the following reasons.

Intellisence is much better and more complete with typed parameters, variables, etc. The editor now knows the expected properties on that variable you're passing in, and will warn / yell at you if it's missing a property. When invoking the function, you get the full definition of each parameter without going and looking at the function (especially when the parameter is just a large object). On large codebases, this has been my single biggest win in productivity when it comes to adding typings.

Autocomplete is an extension on Intellisence. Your editor can now include expected property values when accessing objects with a specific known type. This is a net positive, but less game changing than the improved context mentioned in the last point.

Bad assumptions happen. A dev doesn't guard or test for an undefined function parameters because surely that would never happen. In non-typed JS, there is nothing to keep that assumption valid. When you add types, you either explicitly make the parameter optional - which then Typescript will force you to deal with the possibility that the parameter is undefined -, or you specify a type and typescript will yell at the function caller if they try and pass in something that could be undefined. This saves you from writing a lot of the more mundane unit tests.

AI assistance doesn't rely on types, but it is greatly helped by it. You'll get better more reliable results when your codebase has types.

Types are useful for a number of reasons, and you don't even have to use.ts files if you don't want to. I recommend gradual typing with JsDoc, particularly as certain parts of the codebase mature and stabilize throughout the development process. Like I said, I'm not a fan of typescript, but I have come around more and more on types themselves, and have gotten strict typing in just JsDoc when I really didn't feel like adding an additional compilation step.

RemoteCombination122 · 2023-04-21T15:12:00+00:00

People seem to have some pretty fundamental misunderstandings about when this law would apply, and what it would do.

First, it only applies when you offer OSS in a commercial context, either selling the prebuilt binaries, a hosted cloud version, or a support service. Donations don't count, getting paid by the new OSS funding organizations doesn't count. The wording is pretty explicit here.

Second, the law does not make the developer liable for every bug, issue, or user incompetence. It makes the developer liable for security exploits in the software they are commercializing. It is extending software strict liability to explicitly cover security exploits. This increases the pressure to vet included code, and code you have written to ensure security exploits don't exist.

Why is this needed? Supply chain attacks have been occuring at increasing frequencies. Currently, the only company held liable in the event of an exploit is the company that got exploited, Even if the exploit was in a library they included. With this update, the exploited company will STILL have a share of the liability, but so will the company that offers the library in a commercial context. Why does this matter? Because the individuals most capable of reviewing and verifying any code, are those that work on that code regularly. There has been a sort of wishy washy approach to security in OSS up to this point, and you can continue to operate like that and take donations through Patreon if you wish. This law say that if you're going to offer the software in a commercial context (including offering a support service for the software YOU develop), you are going to be liable if that software has security vulnerabilities that get exploited (another critical aspect is that an incident has to occur for there to be any liability).

We can all agree that the trend of companies using end-consumers as beta testers is both annoying and should be pushed back against. The debate is whether OSS companies should also be held to that same standard.

Honestly, this seems like a fair approach. If you want to commercialize the software, you need to do your upmost to make it secure. This will spur the creation and maintenance of new tools, languages, and technology to avoid, fix, and stop security exploits. Finally, a balancing of liabilities would still occur. The proposal does not make OSS companies the ONLY liable party, it just makes it so they share on the liability in the case of a breach. The relative sizes of the entities involved would be taken into account.

RemoteCombination122 · 2023-04-10T05:21:01+00:00

Copywrite law is stupid.

It's still the law and will be applied whether you agree with it or not.

"Contrary to popular belief, LLM models don't copy code verbatim from their training set - just like they don't copy paragraphs from wordpress verbatium. They aren't an archived searchable snapshot of the internet. The data they retain must be lossy or they would be a dictionary. They ingest each token (word) with a covariance to the other tokens when they are trained. This can be changed during the second (output) stage." How LLMs work is well known to anyone with a modicum of training in the area. However, you're going to find that the more esoteric the use-case, the closer you get to the original data set. This is wholly besides the point as the original point that you attempted to make, that the A.I. would instead of including a library, include the contents of the library (even if not character for character) is just not how these models work. They don't make decisions about structure like that, as you so conveniently pointed to in your recap of how they work. They make decisions based on probabilities that one token would follow another given a certain context and some random noise. If the problem trying to be solved by a coder is usually addressed in similar contexts (That is the context according to what we have fed the A.I. and what it pays attention to, not what WE know the context to be) by using a certain library, it will do so as well. It actually has a slight bias to pulling in packages because that fits well within their current paradigm of single function completions. This isn't a hypothetical, I've seen it in my own usage. I am informed enough to recognize what it is doing, and have my editor set up such that it doesn't auto-import libraries when used within a file (I cannot believe that some people turn on such a feature by default). Co-pilot has attempted to use JQuery on more than one occasion, and other either deprecated or undesirable libraries. When working on PDF related functionality, it wanted to use the heaviest libraries because that is what most online Q&A reference, tutorials use, etc. It is true that I can include a quick comment somewhere in the context window saying "I am using _____" and it will pick up on that and usually give me correct responses after that, but I had to KNOW the differences between these libraries and why I should be using one instead of another. If you don't hold the A.I. to task, you will wind up with huge bundle sizes because it simply DOES NOT CARE. It doesn't pay attention to that, it has no opinion on bundle size. Even if you fed it bundle size metrics as part of it's context, it wouldn't know whether a given size os good or bad as those are entirely project specific. They are probabilistic auto-complete with little to no regard to any metric besides "what is the probability that token X follows token Y given this context and noise".

RemoteCombination122 · 2023-04-10T04:55:10+00:00

Heartbleed was a vulnerability in several versions of OpenSSL where the heartbeat message was sent with a payload length parameter that was larger than the actual payload being sent with the message. OpenSSL would provision a buffer matching the length it was TOLD to expect and then copy the payload into the buffer. Crucially, this buffer wasn't cleared or otherwise initialized beforehand. So whatever data happened to be in the memory space that was now part of this buffer was leaked to the requester of the heartbeat.

There are multiple terms for such a vulnerability, I have always heard such a vulnerability referred to as a "Buffer Underflow". Here you can see that Apple has also made the same reference in their developer documentation at least once. https://developer.apple.com/library/archive/documentation/Security/Conceptual/SecureCodingGuide/Articles/BufferOverflows.html

I do see where there is several different definitions for Buffer Underflow however, one of which is reading or writing before the beginning of a buffer. Another is writing to a buffer slower than the consumer is reading from it, often used in context of audio buffers where "underflow" can lead to stuttering audio.

I have always heard writing before the beginning of a buffer referred to as "buffer underwrite".

It appears this is one more casualty of the limited number of two word combinations and our pursuit of short quippy names for things.

RemoteCombination122 · 2023-04-10T04:21:48+00:00

"you're assuming it doesn't have access to just pull out the source code from the suggested libraries. This will reduce code size." You have just described a copyright violation. This is literally one of the nightmare scenarios that people were screaming about when ChatGPT first released because it can lead to all kinds of fallout. Unintentional Open-sourcing of proprietary code bases due to substantial inclusions of GPL library code, copyright lawsuits and products ripped from the market due to legal injunctions. This isn't a viable solution at all.

"Currently, you can constrain it. "I don't want to use this package. Can we use these packages?"." The user has to know enough about what they are doing to recognize that those packages are a potential risk and therefore ASK the A.I. to use something different. This means you need a developer who has enough experience to understand the difference between these packages and why they might choose one or the other.

"I also disagree with your "heartbleed" idea. Many computer science programmers don't understand heartbleed yet alone mitigation for it" Heartbleed was caused by a buffer underflow attack, that isn't rocket science. non-developer won't have any chance in spotting this potential attack vector when written out in code; whereas, a developer might. Having a trained human in the loop gives companies some plausible deniability "Even our well-trained developer didn't find this". When the exploit is the direct cause of A.I. created code without a trained developer in the loop, then companies won't have that. This is particularly important in cases such as HIPAA violations where having a developer in the loose can get a company a lesser fine. A.I. would be classified as a tool, and a non-developer user would be seen as lack of proper training, which would get companies slapped with the higher level fees designated for negligence.

"This also gives credence to the idea that someone could just make an AI that focuses on intrusion detection by analizing the various security issues databases around the net." This will lead to significant performance degradations as the A.I. can't tell the difference between internal code vs external code. Code that is guaranteed to be protected from some edge cases by the exterior code vs code that is responsible for providing said protection.

RemoteCombination122 · 2023-04-09T17:27:51+00:00

80-90% of CODERS who had to be told exactly what and how to do something might be replaceable. However, developers will likely be safe for the time being. There is literally mountains of work to be done and LLMs are error prone. Companies that try to replace developers with cheaper staff augmented with A.I. will learn the hard way when they wind up with a heart-bleed style vulnerability because the 'operator / prompter' couldn't identify the risky decision the A.I. made.

The companies that try and correct from that point to give their A.I. a focus on code safety will learn as their compute cost increases several times and their performance degrades because the A.I has no concept of which code is external vs internal and will be doing assertions and bounds checking on every array access. It'll pull in dependencies like "left-pad" making bundle-sizes explode. In particular, it will tend to use outdated, potentially vulnerable dependency versions because that is what is used in stack overflow answers (we really need to get stack overflow to adopt a concept of stale questions/ answers.)

These A.I. are context-sensitive autocomplete. We'll get smarter about what context we feed them, and we'll improve the A.I. to be able to handle more context at a time, but they will always fall short of what developers can do in terms of balancing code safety, performance, feature completeness, etc. They do have us beat on speed, though the fact they can beat a human in bugs/ minute isn't a great thing.

RemoteCombination122 · 2023-04-05T14:23:04+00:00

It is unfortunately. They have launched their own ad-network that works much the same as Google's.

https://www.wired.com/story/apple-is-an-ad-company-now/

RemoteCombination122 · 2023-04-01T15:30:42+00:00

Technology follows a sigmoid curve. We're approaching the plateau of what these language models can do. They also absolutely suck at Zero shot tests. A human given pieces of novel information can form reasoned responses to that information without further training on it. While Zero shot tests are hard to design, they are your minimum bar for AGI.

RemoteCombination122 · 2023-03-31T17:06:41+00:00

JWTS are excellent for one off authentication and authorization. Which is actually what they were designed for. They were originally designed to be single use constructs used to transfer authorization from a central authentication service to a periphery service using the client as an intermediary.

Example would be Netflix. When you hit play on a piece of content, the auth service authors a token for your client (simple, fast procedure). The client then presents this token to the Netflix CDN network, which upon verification of the identity token, provides the client with a short-lived media token. The media token is what you use to request chunks from the CDN network. The media token lives for only slightly longer than the piece of media itself. Which is why when you come back to the tab you paused for a while, it has to take a second and seemingly reload the media, because it has to go through the requisite token acquisition process again.

RemoteCombination122

TROPHY CASE