https://en.wikipedia.org/wiki/Fallacies_of_distributed_compu...
61 karma · joined July 30, 2020
https://en.wikipedia.org/wiki/Fallacies_of_distributed_compu...
I expect that the integration libraries probably work pretty well for most users, and implementing a database like BigQuery would be a massive amount of work. So this pretty much explains why Google isn't sprinting to fix this issue.
This is a common misunderstanding that equity funding is free. For the owner of a business, taking outside investment and issuing share in return is diluting the original owners stake in the business. If effect, you are paying for these investments forever because you are giving up some portion of the businesses future profits.
There are certainly situations where this makes sense if you are able to grow much faster with the additional capital. However, the investment is not free.
> But if you need some complex algorithms — particularly algorithms that do a lot of heavy mathematical lifting — then Lisp is the ideal choice.
Is this right? I never thought of LISP as good fit for numerical processing.
With anonymity for consumer how would transactions like exchanges and returns work?
I think these are more common in Europe where people will often take a lump sum pension payout at retirement, and buy an immediate annuity.
This was an issue of an operations team that just did not know how their system worked. Perhaps the system design could have been better. Most likely it could have been, but if Citi had a team of people using a system responsible for billions of dollars without the competence to use it correctly, that failing goes way beyond the UI.
"There’s plenty to love about Pony, but more than anything else, what we love most is that Pony makes it easy to write fast, safe, efficient, highly concurrent programs."
In Erlang you can write safe highly concurrent programs, but you might struggle with fast and efficient. Of course, how much fast and efficient you need depends on what you are trying to do.
A valid comparison would be to compare a Pony program to specific type of Rust program that involves considerable concurrent processing of data.
Pony's killer feature is a type system that allows programs to be written that are guaranteed to be safe from concurrency bugs. Like Rust, the Pony compiler is based on LLVM, and Pony programs compile to native code. Due to the Pony type system, the Pony GC is very efficient. Pony performance is pretty good, but as a language Pony is about much more than performance.
That is not correct. All interactions between the client and the broker are performed in transactional units. If the transaction in which messages are sent fails to commit, then the messages are not sent, and all work is rolled back. Once a message is successfully send (that is, sent and transaction committed), it will be delivered once and only once to the receiver.
Likewise on the receiving side, a message is delivered and the encompassing transaction is committed once and only once. A message may be delivered more than once if the encompassing transaction is later rolled back due to say network failure. But a message delivery in a transaction that does not commit is not a delivery.
The benefit here is that application programmers don't need to concern themselves with message duplicate checking and the risk that duplicate checking is done incorrectly leading to bugs that are very difficult to identify.