harmless | A chinese chess engine | Artificial Intelligence library

You need to remove the fixed height on the .flexbox:

Only when ownership of object pointed by returned value is transferred to user (i.e. you, who write the code calling that factory). An object returned by factory might be actually owned by framework and would be destroyed properly and (almost) never lost. Using smart pointer on those would result in problems, mainly double deletion.

An example of such is Qt framework, where all visual elements destroy their children when they are destroyed and all QObject elements ar "enumerated". A factory there is hidden from user and mostly related to signal-slot system and metaobject data. There are special cases where smart pointers can be used, but Qt provides own flavor of those.

A factory that doesn't own created objects may require some custom steps to delete object directly, in that case you should use proper deleters for smart pointer.

There is a little misunderstanding about statement that in modern C++ "raw pointers are bad". It actually must be worded "raw owning pointers are bad". If you loose value of raw pointer and there is nothing in program that stores its value for purpose of proper deallocation and releasing of resources, it's an owning pointer.

The approach with a Box is totally fine, but you can use painter state to display the indicator only while it's loading like this:

Here is your problem:

Maybe I'm wrong but I always regarded both expressions as "mathematically equivalent" so to say.

They are, but this here is an issue with the borrow checker, it is not perfect, and it has limitations.

In fact pretty much all static type systems without holes have will reject valid programs: the choice is to either reject valid programs or accept invalid ones.

And in this case as Sven Marnach notes it's an artefact of the strict expression evaluation order: if you desugar the call to:

A random (v4) UUID has to provide approximately 128 bits of randomness. In order to do that correctly, it's required to use a PRNG with at least 128 bits of entropy so that the outputs don't end up being correlated or having patterns that prevent them from being independent. That PRNG must also not expose its internal state for the same reason, which means it almost certainly needs to be a CSPRNG.

In addition, UUIDs need to be universally unique: that's why they're called universally unique identifiers. If they were based on a weak PRNG, like one with a 32-bit seed, especially where that seed is based on something simple like the time, different systems could generate identical UUIDs. This could especially be the case if you have a large fleet of systems being deployed at once which all started their time-based weak PRNGs around the same time.

Furthermore, there are CSPRNGs that are extremely fast. ChaCha20, which is the PRNG used in the Linux kernel, can output over 3 GB/s per core. Rust uses ChaCha12 as its default PRNG, which is also cryptographically secure and even faster, and it can be configured to use a per-thread option. I don't know what the default option is for Java, but there's no reason it intriniscally needs to be slow, and since there are many fast, secure options, there's little reason to use weak options when you don't have to.

Finally, it makes sense to use secure defaults. If we gave people an option between fast but non-unique and slower but unique, many people would choose wrong and end up with breakage or security problems because it's a little bit faster. We don't offer those options because, as I mentioned, it's not prudent to offer options which are likely to lead to breakage or security vulnerabilities when there is little need for them and a lot of downsides.

You need to use == and rather use =

From:

There are a number of things to check as Redshift has a number of systems in this area. First, how old was the console recommendation? Also does the table have "Automatic Table Optimization" enabled?

Analyze compression just looks as the size the column can be reduced to if the compression is changes. So just about size and as you rightly point out IO bandwidth. The reason that the improvement could be 0% is likely due to how the data falls into 1MB blocks and no blocks are saved by making the data smaller (at least at the current size of the table).

The console recommendation is a "smarter" algorithm - it looks at more than data size and tries to make "safe" recommendations or change. The major reason that improving a compression can reduced performance is by making the block metadata less effective. So if a column is often used as a WHERE clause Redshift will shy away from recommending additional compression. I've yet to see it be smart enough to look through metadata impacts and compare them correctly with IO bandwidth improvements. So it just gets shy when it isn't sure.

In the case of these other columns where analyze compression says large amounts of size savings are possible it is possible Redshift is being "shy". Are these columns used as WHERE clauses? Especially simple WHERE clauses (col = value) where metadata comparisons are enabled. Just because Redshift didn't recommend these changes to encodings doesn't mean that these are bad to do (or good, or neutral). It just doesn't know enough / isn't smart enough. There are ways to analyze the metadata for these columns and see what the different encodings will do to it but this takes some effort. ENCODE RAW for common, simple WHERE clause columns is a good guess but to know for sure takes work.

Let's observe this specific snippet