I love this and I am horrified at the breadth and depth of the computer history that is being lost to time every day. Yacht handicapping!
The part about us not learning from the past or each other really annoys me as well.
Haskell had so many good ideas, three decades ago, that we’re only just now starting to integrate into modern and popular programming languages.
But then you also have something like Go, which just completely ignores many of these ideas and uses tuple-returns for error handling instead of algebraic data types and so on.Obviously it is a big industry with many different problems and hundred times as much knowledge as any single person could fit into their brain, but so often it feels like a better solution would have been mere steps away.
For example, how did we end up with sysadmins largely using scripting languages instead of compiled languages? You don’t want to have to make a deployment just to know, if your program can be parsed correctly. That’s a huge fucking roundtrip and completely avoidable.
tuple-returns for error handling instead of algebraic data types
What do you mean here?
In Go, when you want to indicate that a method may fail to return a value, you have to make the return value a tuple out of the actual value and a possible error.
The caller is then supposed to check that the error-return-value is null and only then should use the actual value.
That’s better than exceptions, because the caller is aware of failures and because it’s one less language concept, but Haskell, Scala, Rust etc. have a much better solution.
Which is the use of algebraic data types. Instead of returning a tuple, they return a Try/Result value. This value can either be mapped to Success(actual_value) or Failure(error_related_data).
That means the caller is forced to at least acknowledge that that the call may fail in order to get to their value. And the method doesn’t need to return some useless default-value when it failed to produce a value. And you get other usability bonuses like easily being able to handle those Result-values in collections.Here’s a Scala example: https://alvinalexander.com/scala/try-success-failure-example-reading-file/
I just see no advantage to Go’s solution from the language user’s point of view. I guess, it was easier to implement for the language authors and you maybe get a few less language concepts, as you typically want some form of pattern matching to handle those algebraic data types (which I however also think should be included in any modern language, as it’s just incredibly useful on its own).
That’s interesting, thanks
Well, I disagree with your view of what constitutes a better solution, so “lack of agreement” seems like a pretty easy culprit for why things aren’t the way any particular person wishes they could be.
I have not read the article but I remember the algorithm for reverse square root (could be wrong) in the old Quake games has had it’s history forgotten. The field of CS does not keep good records it seems lol.
reverse square root
You mean squaring?
I was wrong on the name. https://en.m.wikipedia.org/wiki/Fast_inverse_square_root
Inverse, reverse, close enough XD.
Right yeah, that makes sense haha
deleted by creator