5,088 karma · joined November 18, 2018
https://youtube.com/AlchemistCamp
https://twitter.com/AlchemistCamp
Warren Buffet and Charley Munger were partners. So were Jobs and Woz. Or Buffet and Gates while playing Bridge many times. There's absolutely nothing romantic or sexual about the word "partner" itself, though of course partnerships exist in those realms as well as in business, sports, music, dance and countless other pursuits.
I've noticed a trend, especially in Commonwealth or European countries to use "partner" to mean "sexual partner" or "romantic partner". However, it's also used in business, sports and many other contexts. Just saying "partner" on its own is less clear than "lover".
At the base level, I suppose my point was about morality, but my intent was about rationality. A country can write laws that it can take all the money a company earns across the entire globe, but it's not a very reasonable position, IMO.
A more accurate version of your analogy would be Ireland choosing to punish a tourist for littering with a dramatically higher penalty than native Irish would face based on their New York salary.
I think a lot of the anger is more about the complexity and price discrimination than the absolute price.
Having watched Chinese-learning apps for a long time, a common failure mode is treating traditional characters as an afterthought, when it’s actually a lot cleaner to use them as a base. simplified variants were made so that readers of traditional characters could easily make the switch, but the reverse is not true. If your db treats “face” and “noodle” or “wind” and “typhoon” as the same character from the beginning, it’s a lot harder to separate later.
def main_loop(%Game{} = game) do
game
|> get_move()
|> play_move()
|> win_check()
|> end_turn()
end
def main_loop(%Game{} = game)
end_turn(win_check(play_move(get_move(game))))
end
schema
|> order_by(^constraint)
|> Repo.all()
|> Repo.preload(preload_opts)
Repo.preload(Repo.all(order_by(schema, ^constraint)), preload_opts)
> if `foo(y)` actually gives you a function to apply to `x` prob you should write `x |> foo(y)()`
If foo(y) returned a function, then to call it with x, you would have to write foo(y).(x) or x |> foo(y).(), so the syntax around calling the anonymous function isn't affected by the pipe. Also, you're not generally going to be using pipelines with functions that return functions so much as with functions that return data which is then consumed as the first argument by the next function in the pipeline. See my previous comment on this thread for more on that point.
There's no inconsistency or ambiguity in the pipeline operator's behavior. It's just syntactic sugar that's handy for making your code easier to read.
The problem is that method-chaining is common in several OO languages, including Ruby. This means the functions on an object return an object, which can then call other functions on itself. In contrast, the pipe operator calls a function, passing in what's on the left side of it as the first argument. In order to work properly, this means you'll need functions that take the data as the first argument and return the same shape to return, whether that's a list, a map, a string or a struct, etc.
When you add a pipe operator to an OO language where method-chaining is common, you'll start getting two different types of APIs and it ends up messier than if you'd just stuck with chaining method calls. I much prefer passing immutable data into a pipeline of functions as Elixir does it, but I'd pick method chaining over a mix of method chaining and pipelines.
Dynamic pricing makes it possible for both riders and drivers to respond to changes in supply and demand. If prices were static, many drivers would prefer to go to a New Year's Eve celebration themselves than work, but when it becomes their biggest paying shift of the year, they're a lot more willing to do it. Riders have to pay a bigger price if they want a ride at peak times, but it's still possible to get one when they really have a strong preference to.
Sometimes nobody else shares the opinion and the “abrasive person” is both good-hearted and right in their belief: https://en.m.wikipedia.org/wiki/Ignaz_Semmelweis
Personally, I’d rather be the kind of person who could have evaluated Semmelweis’s claims dispassionately rather than one who reflexively wrote him off because he was strident in his opinions. Doctors of the second type tragically shortened the lives of those under their care!
In contrast, I don’t know anyone who’s put 10 hours a week into Math Academy for multiple years but those I know who have done it for 6 months have made considerable progress, sometimes the equivalent of years of course work.
Duolingo’s flashy animations and casino-style gamification techniques are actually a negative signal for an educational product.
For the vast majority of people, I’d pick the 70 year-old version even if they did live to 90. With Buffet, I’m not so sure.
> ” The Digital Services Act allows fines of up to 6 percent of a company's total worldwide annual turnover. EU regulators suggested last year that they could calculate fines by including revenue from Musk's other companies, including SpaceX.”
- Logic errors
- Null or Undefined values (prevented in many newer languages)
- Out-of-bounds errors
- Concurrency-related issues
- Arithmetic errors (undefined operations, integer overflow, etc)
- Resource management errors
- I/O errors
- External system failures
- Unhandled exceptions (e.g., RuntimeException in Java)
If you use a language like Rust, you can get help from the type system on several of these points, but ultimately there's a limit to what type systems can do before becoming too complex.
Unless someone who knows those three languages is curious or encounters a particular problem that motivates them to explore, they're unlikely to pick up an immutable, functional language.