jdmichal

Complaint 1: Not being able to use selected columns later in the same select.

    SELECT
        gnarly_calculation AS some_value,
        some_value * 2 AS some_value_doubled

    SELECT
        subquery.*,
        some_value * 2 AS some_value_doubled
    FROM (
        gnarly_calculation AS some_value
    ) AS subquery

    SetWriteTimeout(FactoryClass.factory().SetConnectTimeout(100), 2000).SetReadTimeout(4000);

Java specific: If you're looking for a static utility method, then `UtilClass.` will also autocomplete. However, what if the function you're looking for isn't in `UtilClass`, but `SomeOtherClass`? What if you don't even know whether a method already exists for what you're trying to accomplish, and it could possibly exist in multiple libraries? Your discoverability engine quickly becomes Google.

Right, so there's your 8% per year upside risk. So during US recessions, do international stocks provide a differential return against US stocks that is high enough to support that 8% yearly upside risk?

(And, even if they do, now it's a matter of timing the market...)

> I don't see how that supports the idea that economies are very interconnected and investing outside the country can't produce a large return differential.

I didn't say it wouldn't provide any differential. I implied that that differential will either always be negative or positive but small enough that it's not worth moving.

Or, in other words, US or European recessions would equally tank foreign investments dependent on US or European consumers. Of course these markets would be somewhat resistant based on the strength of their own local economies, but are those economies strong enough to provide solid returns through a US or European recession? And if they are, is the differential high enough to risk the 8% yearly upside during non-recessions?

Not surprisingly, this is also the exact model that hotels use...

> *, **, ***, ****: This person is a danger to me, themself, and others and should be removed from the service

Sure sounds like your exact experience falls under that second group!

And I quote:

> *****: This person deserves to have access to this platform and the ability to earn a living through it

> *, **, ***, ****: This person is a danger to me, themself, and others and should be removed from the service

Sure sounds like your exact experience falls under that second group!

But I'm not a materials engineer. This is just in my lay experience of how thin materials I've encountered perform.

Because that exact same conceptual separation worked so well for Java with checked vs unchecked exceptions...

Everyone just started using unchecked exceptions because they provide an easier coding experience.

Also, there's legitimate situations where the library cannot make that decision, but rather the user. As someone else says in another example, who are you to say that my request to allocate too much memory is a panicable offense? What if my program can, in fact, recover from that situation?

At least in Java, catching checked vs unchecked exceptions is the same if you do choose to handle them.

I didn't even read the full line, because it clearly says not even affiliated. I have no excuse other than posting while distracted.

~~Also, apparently the project is part of Redis.~~

EDIT: My bad, I looked at the bottom of the page and misread the Redis trademark callout as a company copyright. Apologies for any insults!

I didn't even read the full line, because it clearly says not even affiliated. I have no excuse other than posting while distracted.

CRUD patterns where you're pulling out a small group of rows from several tables, you probably want indexes on `JOIN` clauses so that you can quickly find those links using nested loop index scans. And maybe a few indexes on common ways to find records.

Analytics patterns where you're aggregating a large number of rows, indexing `JOIN`s won't help you, because you really want hash or merge joins anyway. Instead, tune your indexes for `WHERE` clauses, because you want a filtered index scans instead of table scans on the reads.

You also want to learn about cardinality and selectivity. Ideally your indexes are organized by selectivity.

It's generally $600 for winnings, and $5000 for withholding.

https://www.irs.gov/pub/irs-news/at-01-17.pdf

https://www.irs.gov/pub/irs-tege/gaming_withholding_reportin...

So the server and the client are both independently calculating the state. But whatever the server calculates is authoritative, and the client's version is just a local simulation that is very accurate, but not 100%. Especially when it comes to other players, where your client is typically just executing under simplistic assumptions of things like constant forward movement.

However, luckily for the client, it receives a data sync from the authoritative server several times a second, so all that potential drift gets quickly corrected while the differences are still extremely small. For your own actions, where your client had access to all your input, the differences are probably even too small to notice. For other players though, it will be more noticeable, especially if there's an abrupt change in input.

> Biochar is the lightweight black residue, made of carbon and ashes, remaining after the pyrolysis of biomass. Biochar is defined by the International Biochar Initiative as "the solid material obtained from the thermochemical conversion of biomass in an oxygen-limited environment".

You may be thinking of biochar specifically as a soil amendment, where it is sometimes loaded with probiotics and such:

https://en.wikipedia.org/wiki/Biochar#Soil_amendment

> She pointed out that when pre-charged with these beneficial organisms, biochar promotes good soil and plant health.

IANAL, but this sounds appropriate to me? Couldn't all forms evidence be hit with various types of "this might be fake" claims? So I think it's fair that the court assert that you must claim "this is fake", then be willing to battle it out with the opposing side. Otherwise it's not a defense, it's just empty words, isn't it?

I've seen other systems essentially say, "Oops both versions modified this file... Good luck!" It didn't matter that the modifications were to very different parts of the file. I've never seen that in Git. Any merge conflict I've gotten in Git has been a true potential conflict, even if the resolution is straight-forward from my perspective.

So apparently there's two great reason to move away from Bitbucket. Not supporting arm builds and apparently you're one exploit away from other builds on the same machine having access to yours?

https://jira.atlassian.com/browse/BCLOUD-15317