But yeah, it seems 100% deliberate because most people wouldn't probably care after reading the title. It's academic clickbait techniques.
1,320 karma · joined November 13, 2013
But yeah, it seems 100% deliberate because most people wouldn't probably care after reading the title. It's academic clickbait techniques.
Personally, I use Syncthing to sync between devices, including a NAS as a target, which regularly backs up to Backblaze.
Of course you have the option to just not do that in your code, but it's nice to have a hard guarantee that this can never happen, even by accident. I could have used a deque as a backend and wrapped it in the class, though.
- Reasoning: It's used in cases where you'd ideally use an array because you want contiguous memory (because you'll usually iterate through them in order), but you don't know beforehand how many elements you'll insert. But you can't use a resizeable version like std::vector, because it invalidates any pointers to the elements you've already allocated, and you need to store those pointers.
- Implementation: As a black box, it's used like a list: you index elements with an integer, and you can append to the end. But internally it uses different lists. Like a std::vector, it starts with an allocated size, and when it needs a bigger size, it allocates newer blocks that are "added" to the end, but doesn't move the already allocated elements.
- Downsides: Data is not all contiguous, at some point there are jumps between elements that should be close together. For performance when iterating, it's negligible since those cache misses happen "rarely" (depends on the block size, bigger block size means better cache performance but more potential wasted allocated memory), and most of the time you're iterating from start to end. But this means that you can't use this structure with algorithms that use "pointer + size", since internally it doesn't work like that. And since internally you can't shrink the lists and invalidate pointers, there's no way to delete elements, but in my case it's not a problem since I'd reuse indices afterwards with an added structure.
- Applications: I used it when coding games, when you have a big list of entities/components but you don't know how many beforehand. You access them by index, you might store pointers to elements, and most of the time you'll iterate through the whole list (when updating, drawing, etc.).
It could be useful for power users, though.
None of those things happen in lists.
Edit: Sorry, that was a bit harsh. I do hope that things improved with your condition after all.
AROSE UNTIL DUCHY BLIMP GAWKS
https://en.wikipedia.org/wiki/Kushim_(Uruk_Period)
I didn't find a mention of him making a mistake in this article, but I think I read somewhere a while ago that the numbers he wrote on the tablets had some error somewhere.
Example: Start at 52 seconds, take 10 minutes after that:
ffmpeg -ss 52 -i input.mp4 -c copy -t 00:10:00.0 output.mp4