icrbow

Ada can't bootstrap? Ironic...

We humans love quantifiability.

No. Screw quantifiability. I don't want "we've improved the sota by 1.931%" on basically anything that matters. Show me improvements that are obvious, improvements that stand out.

Claude Plays Pokemon is one of the few really important "benchmarks". No numbers, just the progress and the mood.

Not for long.

ECS library that will do it in AoS way

TLAs aren't my forte. It's SoA of course.

does Haskell have a special construct that allows for values to be overwritten

Yes and no.

No, the language doesn't have a special construct. Yes, there are all kinds of mutable values for different usage patterns and restrictions.

Most likely you end up with mutable containers with some space reserved for entity state.

You can start with putting `IORef EntityState` as a field and let the `update` write there. Or multiple fields for state sub-parts that mutate at different rates. The next step is putting all entity state into big blobs of data and let entities keep an index to their stuff inside that big blob. If your entities are a mishmash of data, then there's `apecs`, ECS library that will do it in AoS way. It even can do concurrent updates in STM if you need that.

Going further, there's `massiv` library with integrated task supervisor and `repa`/`accelerate` that can produce even faster kernels. Finally, you can have your happy Haskell glue code and offload all the difficult work to GPU with `vulkan` compute.

Flame bait

I'll take it.

ChatGPT is the new techno-atheist's substitute for God

Not really, no ~~true~~ AInotKillingeveryoneIst says that ChatGPT (or GPT-like) is ASI. Please stop beating this particular strawman.

Debug.Trace has a lots of stuff for that. You can even generate charts from that when using eventlog-enabled runtime.

Yes. The amount of job postings raises year to year.

For the reference, 2017 was the year of GHC 8.0. Since your decision to never look back there were a lot of good things.

The standard didn't come out because of some failure to make it. It was mostly the lack of interest that killed it. I wouldn't be betting that some alternative universe where Haskell Prime pulled through had a noticeable increase of adoption because of this.

Looking at proposals, arguments "from standard" don't tend to generate enough support. What wins hearts is alleviating someone's pain without taking disproportionate externalities.

I used to wrap everything in Nginx, but `warp` can hold its own candle, with HTTP2 and stuff. One less piece to configure.

For practical purposes you don't have to know what the monad "is". You need some good practical examples how to wield them.

Knowing some prehistory about doesn't affect usage. And metaphors are very tricky and personal.

The personal part is where the "monad tutorials" fall flat. They assume shared context which may or not may not be actually shared by a random reader on the internet. Yes, some monads are really about "wrapping a value" or whatever.

Reading a post using this metaphor when you want such a wrapping and/or deal with chaining wrappers regularly can bootstrap your understanding in no time. But if you're reading "wrapper"-flavored tutorial while dealing with "pipes" then the spell breaks, you end up confused, and another one joins the "monads are uncomprehensible" group.

Teaching is hard enough. Writing good tutorials is even harder. Successfully giving an universally good drive-by explanation is next to zero probability.

I suspect this is a knowledge variant of "XY problem" and you have to establish more context before answering.

And another problem that "what is a monad" is already a meme. Everyone has the burning desire to ask it, but usually there's no practical need for the answer. Without that confusion ensues. Or, even worse, a false understanding gets locked in and starts to proliferate, sustaining the memetic chain reaction.

This. Just point to the definition in your language (NOT the category theory, unless that's what you're coding in).

In Haskell, a Monad is a type class with a method `bind`. In Scala that would be a `flatten` or whatever.

If a person who's asking doesn't yet know what the "type class" is, or how to read signatures, your "monad tutorial" would not make much sense anywat. Guide them to learn the prerequisites first.

You say "by wrapping a value" and then confuse it with the wrapper right away. No, monads are not wrappers. Some wrappers are monads, but not all. inb4, monads are not pipes either.

I've seen a company doing that in Visual Basic. It was successful enough to have a nice office etc.

It may be wise. The stack being mainstream is only a part of the equation to consider. It can be easily dwarfed by other variables, like "fun".

E.g. even if "getting your face hit by a brick, hourly" is a more widely demanded skill and has more job openings than Haskell I'd still pick the latter.

It's like explaining a hand with four fingers and a thumb. The whole story is... ugh. But you can grasp enough of it to start using almost right away.

At a glance, it looks like it would have quite a few accessibility issues.

LLMs can't massively decrease the net amount of entropy of the universe

Rust's type system is good enough

Good enough for what?

close enough to Haskell

Close enough for what?

with new paradigms that Haskell hasn't yet fully adopted (borrowing, etc)

Honestly, I don't want to think about borrowing. For my gamedev/rendering tasks I have resource regions (as a library) and trust the runtime to do its thing.

If you don't know how to make one already you will be racing towards the precipice, not steering away from it.

No reason other than making a kernel with a sane security model?

Like we have a bunch of those under each tree in a park...

I don't know abut NN prediction, but apparently you can bootstrap anything* with strategically placed 15 gliders.

https://btm.qva.mybluehost.me/building-arbitrary-life-patter...

This one is absolutely golden. Read down typeclassopedia, do this one and you're basically ready to ship.

Security is resilience with respect to your threat model. The usual security objectives are confidentiality, integrity, and availability.

Nothing is "secure" forever and ever. For each objective you need to state some assumptions that are required to uphold it.

Haskell allows you to express more assumptions in code, not just comments, to be enforced at compile time. And with some careful handling Haskell types provide a solid foundation without going into full deductive verification mode.

ListT removal isn't bold. It was known for a long time that it needs to go and you should use one of the explicit alternatives instead.

Too late. The people are making money with Haskell for quite a few years by now.

Why bother with nginx or whatever if its native server is http3-capable and performant enough by itself?

No.

Haskell doesn't have sum types

Say what?..

LOL. No, it's not. The gold standard is an emotional reason.

Maybe the emotional reason is a warm fuzzy standard?