Yeah I was more interested in why you haven't saved a baby's life for $4000. Maybe I'm being presumptuous, but even if you don't have $4000 in savings and liquid investments you could probably get a loan for $4000, or extend your mortgage. A baby is going to die if you don't.
Do you have a want to please millions of people whose lives are improved by exactly the product that your company sells? I could certainly do without that, but it does sound nice.
> Once they define it as stealing, then it's morally indefensible, by definition.
Right, similar to the equivocation around the meaning of earn in this thread. I've started to wonder whether it's possible to push by accepting that framing and then asking for a justification rather than quibbling about what "stealing" is.
Some of that 30% has both directly and indirectly empowered war crimes and has pushed on the accelerator of an unspeakable [and, sadly, irreversible] descent into the kind of mad fascistic experiment that always ends up driving many more. The seizure of means that you turn around and use for rent-seeking is morally indefensible in its own right, but it’s the unintended (yet obvious) consequences of that same self-serving and short-sighted impulse where the real moral trap lies.
What AOC is trying to do here is shift the debate from extracting retribution on people who have violated specific laws (a fair and an honest way to enforce justice in a civil society) to extracting retribution on people who she insinuates "must have done something immoral" based on their net worth (a selfish, dishonest, envious and greedy way to run a society). It's a clever play, and unfortunately for the people of the world who value freedom and a high standard of living, it's going to work. There is enough of the population filled with envy and greed that they'll lap up whatever a politician tells them bogie man of the day is. Historically it's been the aristocracy, Jews, immigrants, but those don't work any more, so now it's generally "the rich". Billionaires are the thin end of the wedge. After them it will be business owners of all kinds, people with second homes, people who send their children to private schools, and generally anyone who has anything else that someone might envy. It's clear that the way society is going people are going to keep lapping this stuff up.
HN used to be open minded about people creating wealth. The change is shocking to me, actually.
>There is enough of the population filled with envy and greed that they'll lap up whatever a politician tells them bogie man of the day is. Historically it's been the aristocracy, Jews, immigrants, but those don't work any more, so now it's generally "the rich".
I love how the billionaires hoarding resources to entrench their own power are not the greedy ones in your telling.
Oh, I don't know any of those. The only billionaires I know of are those providing service to consumers or businesses that people can freely decide whether to pay for or not. I just subscribed to another thing on Amazon for far less in price than the value I get for it. Thanks Bezos!
The selfish people I know of are politicians and online commenters who think they're entitled to the wealth built by other people.
Okay but the quote in question and this topic generally is more than just the billionaires you know of and the value you personally get from them -- it's about how billionaires exist in the system as a whole, and what it takes to become one.
Yeah, it should be about the value everyone gets from billionaires. I would love there to be more billionaires. It would be a sign that more and more wealth is being created in society. More billionaires should exist!
It's my belief that all effects can be done with dependency injection in some form, at least, I'm not familiar with ones that can't. Even arbitrary delimited continuations can be implemented by injecting a reference to the continuation prompt on the stack.
That's very interesting, thanks! It gave me a brainwave and I wondered I could implement that in Bluefin. I'm pretty sure Bluefin's Request[1] is a second class stackful coroutine, and sure enough it turns out to be possible, so I'm pleased about that.
-- ghci> example
-- Hello
-- World
-- Timed out
example = runEff $ \io -> awaitYield (receiver io) sender
receiver ::
(e1 <: es, e2 <: es) =>
IOE e1 ->
Await String e2 ->
Eff es ()
receiver io a = do
r1 <- await a
effIO io (putStrLn r1)
r2 <- await a
effIO io (putStrLn r2)
mr3 <- timeout io 0 (await a)
effIO io $ case mr3 of
Nothing -> putStrLn "Timed out"
Just r3 -> putStrLn r3
sender ::
e1 <: es =>
Yield String e1 ->
Eff es ()
sender y = do
yield y "Hello"
yield y "World"
yield y "More"
timeout ::
e1 <: es =>
IOE e1 ->
Int ->
Eff es r ->
Eff es (Maybe r)
timeout io t m = withEffToIO
(\effToIO -> System.Timeout.timeout t (effToIO (\_ -> useImpl m)))
io
> I dislike the concept of having a second, hidden, control flow that might get sprung up upon function callers, because it has side effects buried in the implementation of a callee that are not defined in the parameters or the returns
You might like my capability-based effect system for Haskell, Bluefin[1], then. If a Bluefin effectful function throws you can see it in the type system. If you want to have the capability to throw, you need to pass in an argument of type Throw. For example here "workWithThrow" can only throw an exception because it is passed the Throw capability.
workWithThrow ::
(e1 :> es) =>
Throw String e1 ->
Int ->
Int ->
Eff es Int
workWithThrow t x y = do
let result = x + y
when (result > 10) $ do
throw t "Too big"
pure result
-- ghci> example
-- Left "Too big"
example :: Either String Int
example = runPureEff $ try $ \t -> do
workWithThrow t 5 7
Not sure why people are saying "you can't" when it seems to me the whole point of algebraic effects that you can. You can define g so that it has no ability to do "general IO", all it can do is yield log messages. Then f can call g in a way that turns the log messages into writes to stdout. For example, here's how you would do it in Bluefin:
type Log = Yield String
-- workWithLogging cannot do arbitrary IO!
-- All it can do is yield log messages, which
-- must be processed elsewhere.
workWithLogging ::
(e1 :> es) =>
Log e1 ->
Int ->
Int ->
Eff es Int
workWithLogging l x y = do
yield l ("x was " <> show x)
yield l ("y was " <> show y)
let result = x + y
yield l ("result was " <> show result)
pure result
-- ghci> example
-- x was 5
-- y was 7
-- result was 12
-- 12
example :: IO Int
example = runEff $ \io -> do
-- forEach determines how each log message
-- should be handled.
forEach
(\l-> workWithLogging l 5 7)
(\logMsg -> effIO io (putStrLn logMsg))
reply