This paper is up to Oleg's usual high standard, and is a very important step to read if you're catching up on the history of effect systems in Haskell.
As a user, I think effect libraries in Haskell trade off between five main constraints:
* Typelevel wizardry
* Boilerplate
* Performance
* Ability to handle "higher-order" effects (e.g., `bracket`)
* Safety (e.g., not accidentally leaking effects beyond their scope)
The most compelling libraries I've seen from the industrial perspective are the "IO-wrapper" libraries like `cleff`, `effectful`, and `bluefin`. These libraries tend to give good performance, can handle higher-order effects, but trade off a little safety to get the typelevel stuff down a bit. Of these, I currently favour `effectful` but am keeping an eye on `bluefin` (which is very close to `effectful` but with explicit handle-passing). The explicit handle-passing in `bluefin` seems to get the typelevel down a bit more in exchange for asking the user to write a little more boilerplate to explicitly pass handles around.
I also clicked through ten pages of Google search results for "capitalism is the worst economic system, except for all the others", each of which showed the literal quotes in the preview excerpts, at which point I became too bored to continue.
It is a fantastic read. I find myself quoting section 5.3.1 on Well-Behaved Functions (WBFs) quite often, especially rule 2: "If the specification doesn’t say what to do raise an exception."
This really helps systems from muddling along into bizarre states, where things are going awry and nobody knows why.
I think this is one of the deepest problems with modern UIs - event delivery is no longer reliable. You type "abc" and only "ac" gets delivered to the application, or "b" ends up sent to another window. Maddening.
It was an absolutely bone-headed poke-the-bear move and we should count ourselves lucky that it was only a chunk of the library and not the whole archive that got nuked. IA holds priceless and irreplaceable data, and while the library initiative was a well-intentioned move during the pandemic it was way too radical for the keepers of our shared digital history.
And this is why I respect Anna's Archive. If we want information to be free, I think we should consider intentionally violating copyright as an act of civil disobedience. I'm not sure I'm ready to go that far, but I respect the people at AA who are.
Agreed. It was poking the bear. The other big three grey-circuit services have nothing to lose because they never claimed to be legit.
If you claim the moral high ground you have to be impeccable. It also didn't help anyone during COVID because all the stuff was out there already on less legit services. Some make it super easy with telegram bots etc.
I'm sad that they screwed this up. Because the archive is a very valuable service. They've lost a lot of money, goodwill and reputation now. And gained nothing.
The worst part is, it's unimaginable that this would ever have ended well.
It wasn't a bad idea in principle but they should have worked to get some publishers on board, could have been a PR win for them too.
There have been a few mentions in this thread of portable gaming PCs like the Steam Deck and the ROG Ally. Has anyone here tried using them as a primary machine? I've been thinking that since I travel with a portable keyboard and mouse anyway, maybe one of those machines might not be too bad for actual work?
Lenses also let you take interesting alternate perspectives on your data. You can have a lens that indexes into a bit of an integer, letting you get/set a boolean, for example.
As a user, I think effect libraries in Haskell trade off between five main constraints:
* Typelevel wizardry
* Boilerplate
* Performance
* Ability to handle "higher-order" effects (e.g., `bracket`)
* Safety (e.g., not accidentally leaking effects beyond their scope)
The most compelling libraries I've seen from the industrial perspective are the "IO-wrapper" libraries like `cleff`, `effectful`, and `bluefin`. These libraries tend to give good performance, can handle higher-order effects, but trade off a little safety to get the typelevel stuff down a bit. Of these, I currently favour `effectful` but am keeping an eye on `bluefin` (which is very close to `effectful` but with explicit handle-passing). The explicit handle-passing in `bluefin` seems to get the typelevel down a bit more in exchange for asking the user to write a little more boilerplate to explicitly pass handles around.
reply