Programming languages and their relationship styles
maradydd.livejournal.com
maradydd.livejournal.com
Based on the descriptions, I'd guess the author only has experience with C++, Python, Prolog, and possibly Java. That's a bit like someone who's only ever eaten frozen waffles, frozen pizza, and canned soup trying to write a comparative list of world cuisine.
And I don't think anyone would disagree that Haskell is extremely serious about safety ("prophylactic techniques") and carefully marking impure portions of the program by tainting them with IO.
The only part of the Haskell description I didn't get is the "person you're with no longer resembles Haskell."
Haskell isn't a pure language. Its only notable characteristic regarding purity is that it's possible to annotate whether some code is pure or not. Working with impure (and sometimes downright unsafe) is common, encouraged, and widespread. Especially in real-world code.
Haskell doesn't utterly reject OO; if anything, its combination of typeclasses and nearly-free threads brings it closer to Smalltalk or Erlang than many pretend-OO languages (C++, Java, C#).
Default laziness is one of the few truly weird parts of Haskell, and I sincerely doubt the author has done anything serious enough to worry about the evaluation model.
Isn't this a requirement (the use of the type system for annotating purity), not something that is just "possible". And isn't that what people generally mean by its purity?
Some people get confused between purity and expressiveness. Inexpressive languages like C require using impure constructs to represent fundamentally pure constructs. More expressive languages like Python don't need as many impure workarounds. Haskell, as a very expressive language, can do amazing things in pure code that other languages must resort to impurity for.
If you want a pure language, look into Agda or Coq.
Haskell was historically pure and had side effects added as a way to interact with the world. The language enforces (discounting unsafePerformIO) the separation of pure and impure code. That is sufficient to label any practical language pure.
That's actually not true -- you can write the core of a system in a pure language, then use that pure core as a library in larger applications. Pure languages like Coq and Agda are often not Turing-complete, so various sorts of verification and proofs can be applied more easily.
Haskell's type system is decidable. Thus it can't be Turing complete.
C++'s type system is isomorph to lambda calculus even without extensions, and nobody made this joke there.
That was hilarious and disturbing at the same time.
"C#
Well, you're a big girl now -- all grown up and the heiress of a promising diamond mine. But you're also a politician bucking to be the first female president. You've promised to be everything all of your predecessors were and everything they could not be.
You look strangely familiar like an old girlfriend who has had a facelift and who has been in the witness relocation program. The wig and wheelchair don't fool those who can smell your scent and those of us who see that little switch at the back of the wheelchair that says "/unsafe" which is a euphemism for "release the whore" or “Unleashed! Now Scks And Fcks Everybody.”
Once flipped, you'll be doing all of the nasty things we secretly like, but hired you not to do. But once we know you can be that whore, that's all you'll ever be... and at the dinner-party / political fund-raiser, your diamonds will still sparkle. Wipe your mouth, honey. "