9GAG

Try attaching gas instead of deposit. Here's an example using the CLI:

I would definitely not advise you to store these types of workloads in Memcached or Redis and I would also not advise you to have these workloads processed by PHP.

Varnish is indeed the way to go here.

Memcached and Redis are distributed key value stores. They are extremely fast and scalable and are perfect to store small values that change on a regular basis.

Image and video files are quite large and wouldn't really fit well in these memory-only databases. Keep in mind that Redis and Memcached aren't directly accessible from the web, they are caches that you would call from a web application.

That means there is additional latency running them through an application runtime like PHP.

Don't get me wrong, I'm a huge PHP fan and have been part of the PHP community since 2007. PHP is great for building web pages, but not so great for processing binary data.

These types of workloads that you're looking to process can easily overwhelm a PHP-FPM or PHP-CLI runtime.

It is possible to use PHP, but you'll need so many servers to handle video and image processing at large scale, that it will become an operational burden.

Varnish is a reverse caching proxy that sits in front of your web application, unlike distributed caches like Memcached and Redis that sit behind your web application.

This mean you can just store images and videos on the disk of your webserver and Varnish will cache requested content in memory without having to access the webserver upon every request.

Varnish is built for large-scale HTTP processing and is extremely good at handling HTTP responses of any size at large scale.

Varnish is software that is used by CDNs and OTT video streaming platforms to deliver imagery and online video.

Using video protocols like HLS, MPEG-DASH or CMAF, these streaming videos are chunked up in segments and indexed in manifest files.

A single Varnish server can serve these with sub-millisecond latency with a bandwidth up to 500 Gbps and a concurrency of about 100,000 requests.

The amount of machines you need will be way less than if you'd do this in PHP.

The Varnish Configuration Language, which is the domain-specific programming language that comes with Varnish, can also be used to perform certain customization tasks within the request/response flow.

The VCL code is only required to extend standard behavior, whereas in regular development languages like PHP you have to define all the behavior in code.

Here's a couple of Varnish-related resources:

• The Varnish Developer Portal: https://www.varnish-software.com/developers/
• The Varnish documentation: http://varnish-cache.org/docs/
• The Varnish 6 By Example book that I wrote: https://info.varnish-software.com/resources/varnish-6-by-example-book

The only challenge is caching massive amounts of image/video content. Because Varnish stores everything in memory, you'll need enough memory to store all the content.

Although you can scale Varnish horizontally and use consistent hashing algorithms to balance the content across multiple Varnish servers, you'll probably still need quite a number of servers. This depends on the amount of content that needs to be stored in cache at all times.

If your origin web platform is powerful enough to handle requests for uncached long-tail content, Varnish could store the hot content in memory and trigger caches misses for that long-tail content. That way you might not need a lot of caching servers. This mainly depends on the traffic patterns of your platform.

The open source version of Varnish does have a file storage engine, but it behaves really poorly and is prone to disk fragmentation at large scale. This will slow you down quite significantly as write operations increase.

To tackle this issue Varnish Software, the commercial entity behind the open source project, came up with the Massive Storage Engine (MSE). MSE tackles the typical issues that come with file caching in a very powerful way.

The technology is used by some of the biggest video streaming platforms in the world.

See https://docs.varnish-software.com/varnish-cache-plus/features/mse/ for more information about MSE.

Varnish Enterprise and MSE are not free and open source. It's up to you to figure out what would be the cheaper solution from a total cost of ownership point of view: managing a lot of memory-based open source Varnish servers or paying the license fees of a limited amount of Varnish Enterprise servers with MSE.

Benji at https://discord.com/channels/490367152054992913/542945453533036544/912840246524260355 suggested that instead of using --amount 3 I use --amount 3 --gas=75000000000000, which worked.

I think this should accomplish what you are trying to do. Instead of structuring the way you have, I've tracked whether you are in a long or not. Keep in mind orders are executed on the open of the next bar from the signal. Green arrows represent the bar where the condition to enter occurred, the red x where the condition was met to close the position.

We use barstate.isconfirmed to check the conditions right on the closing of the current bar. To keep it cleaner, I've separated the logic from the entry/close commands by using bool variables enter_long and exit_long. We can then also use these boolean variables to plotshape() to visually check the logic. If you have additional conditions you want to add later you can either use the same bool to flip the one entry command or have multiple different bools for each type of entry condition ie enter_x_long or enter_y_long etc. When things inevitably don't work as planned having plotshape() mapping out your different conditions will make it a lot easier to debug.

It can also be helpful when coding these kinds of things to plot your levels like candlehigh to debug.

Simple every changing for src should load the video , using media load load(), and if you want to start it on show just trigger play() on video as following :

I need to change 'source' to 'url':

Looking at the HTML, there aren't

You can make use of Facebook's Graph API.

https://graph.facebook.com/v7.0/?fields=og_object&id=https://9gag.com/gag/avPBX3b

JSON Output:

First, you can use caching. With tiles, like it's done in cartography. You'll still need to go over all the points, but after that you'll be able zoom-in/zoom-out quite rapidly.

But if you don't have extra memory for cache (not so much actually, much less than the data itself), or don't have time to go over all the points you can use probabilistic approach.

It can be as simple as peeking only every other point (or every 10th point or whatever suits you). It yields decent results for some data. Again in cartography it works quite well for shorelines, but not so well for houses or administrative boarders - anything with a lot of straight lines.

Or you can take a more hardcore probabilistic approach: randomly peek some points, and if, for example, there're 100 data points that hit pixel one and only 50 hit pixel two, then you can more or less safely assume that if you'll continue to peek points still pixel one will be twice as likely to be hit that pixel two. So you can just give up and draw pixel one with a twice more heavy color.

Also consider how much data you can and want to put in a pixel. If you'll draw a pixel in black and white, then there're only 256 variants of color. And you don't need to be more precise. Or if you're going to draw a pixel in full color then you still need to ask yourself: will anyone notice the difference between something like rgb(123,12,54) and rgb(123,11,54)?