@Rahul2001 That's such a bad set of puns it Hertz. I'm shocked because I thought you were grounded and wouldn't write such revolting rubbish. I'm charging you and pulling the plug on this thread and sending you ohm for your punishment
@djsmiley2k it's similar, actually :P the S4 might be a little physically larger, but the J3 would have more modern components, it runs the latest Android pretty well
the latest gen budget phones use the modern fab processes like current flagship phones do, but they get cut-down chips that are cheaper to make, or high-end SoCs that had problems with them, they disable some of the cores or run the clock lower during the binning process
> The company is not specifying how many program/erase cycles its 3D QLC NAND will handle, but various industry predictions over the years have suggested 100 – 150 P/E cycles as a reasonable goal for QLC NAND, which is considerably lower than approximately 1000 P/E cycles supported by TLC NAND.
@bwDraco actually, if your OS drive is on some other storage technology, for many gamers a secondary high capacity drive with that QLC would be just fine
However, the fact that this sort of NAND is becoming necessary rather than "a nice thing to have for cheap applications" shows that we are knee-deep in the NAND shortage.
@BenN Nope, see. If I use a standard password, and verify it server-side, it can be intercepted, right? And it wouldn't matter even if I hashed it before sending it, because then a malicious dude could just send the hash over and get authenticated
@BenN Well, what if when I login, I send the "password+thecurrenttime" hashed? And then verify it at the server? It wouldn't help if the malicious dude got the hash, because it would keep changing. Unless he can spoof the thing within a second
I'd pay $700 for an 8 TB near-WORM 3D QLC SATA SSD for storing my Steam library, as long as the read perf and read IOPS was comparable with, like, the 850 Evo
So, gave this QLC some thought: I'm kinda thinking that if they can manufacture and market a QLC storage device appropriately (backup drives, read-focused nearline), they could sell. They absolutely need to get the cost down as low as possible, though.
If they market it improperly and shoehorn QLC NAND into, say, a 256 GB-class general-purpose SSD that dies after scarcely more than 20 TBW of host writes, their reputation is going to suffer badly.
(Yes, I do have more than 20 TBW on my main laptop's SSD, which is 2.5 years old. I'm not afraid of it failing because it has Samsung 3D MLC NAND.)
Speaking of Samsung 3D NAND, in hindsight, it's just astounding how far ahead of its time it was, to the point where an almost 2.5-year-old SSD model is still sold today essentially unchanged from its original release and still leads the category by a wide margin.
I have several different backup systems in place - the only truly offsite backups are my photo archives (and yes, I've had to restore from them), but I try to put my most critical data on multiple external drives.
In Windows, there is a service named DNS Client service (dnscache) caches DNS names and registers the full computer name. When it is running only svchost.exe connects to DNS server. Then I stop and delete that service with the following process::
Set dependency of Network Store Interface Servic...
I had a lot of fun puzzling out how to create "real" 2D arrays (NOT jagged arrays) in PowerShell that could be marshalled over COM to Excel to store in the Value2 property which would set a range of Excel cells' values in a single COM roundtrip, improving performance by about 10000x over setting individual cells
I wrote a nested loop in PSH to convert a .NET jagged array (arrays of arrays) to a 2D array, and that n^2 complexity is still way faster than the COM calls for individual .Value setting for each item
because each iteration of the inner loop is all within the PowerShell .NET runtime, it isn't cross process IPC
@djsmiley2k a 2D array is a linear memory block of values where each row has the same number of columns (it's simply an assumption that's made) and you tell the system upon memory allocation how many rows and columns, it multiplies them together and gives you a buffer large enough to hold rows*cols items
a jagged array is a single dimensional linear array of "object pointers" where each object pointer points to another single dimensional array, each of which has its own arbitrary size and can reside in different regions of memory too
so if you want to deep copy an entire jagged array and all element boxes, you have to copy the overarching "row array" as well as the contents of each pointed-to array (which can reside in other areas of memory)
if you want to deep copy a 2D array, as long as you know the pointer that starts the buffer and the size in bytes of the buffer, a single memcpy() will copy the entire array
in native code, assembly, C/C++, COM interop on Windows, and the .NET Runtime, 2D arrays are possible; in some languages, only jagged arrays are possible
jagged: a = [ b, c, d, e, f ] where each of b/c/d/e/f is its own separate 1D array, with its own pointer to a region in memory where its contents reside and has its own independent size or length
2D: a = [ b c d e ] where the b/c/d/e are elements of data (not arrays!) and we visually "treat" the first two values as row 1, column 1 for b; row 1, column 2 for d; row 2, column 1 for e; and row 2, column 2 for e
memory itself is logically laid out in linear blocks, not 2D, though, so any time you talk about higher dimensional arrays in programming, they're just represented as linear "buffers" of bytes (basically a native C array) in memory
the fact that it's higher dimensional is an illusion that the programmer or the syntax of the language imagines onto it
and in some languages you can access a 2D array's elements with single dimensional array access methods
a[2] in 0-indexed array access in C would give you 3 in Ben's example above
jagged arrays are considerably less space efficient if you intend to use every possible cell in a 2D array, but are extremely efficient if you intend to have "sparse" values
basically imagine a 2D matrix of points, like the multiplication table -- if you intend to have a lot of "holes" where there's no data and you never intend to put any data there, jagged arrays are more efficient
if you know in advance that most or all of the places in the grid will be filled with meaningful data, a 2D array is more efficient
Maps and Dictionaries are conceptually like jagged arrays in some ways (though they're often stored under the hood in a hash table), and it would be very inefficient to represent a Map or a Dictionary with a 2D array in memory
because Bob may have 16 phones (so a[0].size would be 16) but djsmiley might have one phone, so a[1].size would be 1
if you had to store that in a 2D array you'd need to allocate as many "columns" as needed for all the people and the maximum number of phones one person can have, so if someone just has one phone, they waste tons of memory
What are the differences between multidimensional arrays double[,] and array-of-arrays double[][] in C#?
If there is a difference, what is the best use for each one?
In Windows, there is a service named DNS Client service (dnscache) caches DNS names and registers the full computer name. When it is running only svchost.exe connects to DNS server. Then I stop and delete that service with the following process::
Set dependency of Network Store Interface Servic...
What are the differences between multidimensional arrays double[,] and array-of-arrays double[][] in C#?
If there is a difference, what is the best use for each one?
