353 karma · joined December 8, 2021
For Lua last time I tried I just did not install any Lua extension, just use the native syntax highlighting and move on.
That a very big "only". For me that's the killer app. I do not trust financial institutions and the ones that I trust do not want to accept me as their customer.
> “the average person doesn’t care about decentralization”
It's like saying "the average person does not care about a system of interconnected computer networks that communicates through TCP/IP". The average person cares about watching reels on Instagram or sending messages through WhatsApp.
> That’s what blockchain technology is: interesting research which will never be popular
I have no doubt that someone said the same regarding the Internet.
> If nobody is using blockchain technology outside of blockchain projects
HN is very adverse to the blockchain space. This is not the best place to look for people using the technology since 9/10 times you would get downvoted to oblivion
I would never accept such PR. This kind of policies then end up biting you in the long run (experience talking)
a =
let foo = 10
bar = foo + 32
in foo * bar
b =
1
& (+ 2)
& (* 9)
& (/ 5)Not exactly correct due to the lack of higher order effects (https://news.ycombinator.com/item?id=20513370), but the condition system is "good enough" for a lot of use cases
As someone who uses Haskell professionally, 100% agree. Monad transformers are an (unfortunate) solution to the problem of stacking effects, not only due to the required lifting (to pick the appropriate handler), but due to the lack of compositionality and rough UX for the developer. Algebraic effect libraries are a lot easier to use (but I cannot speak for how easy/hard are to implement).
How has this failed? Every month I transact in crypto while I could not do the same using traditional methods.
This is just an "old man rants at cloud" take.
For starters this is not the case, it does not work on a string of numbers:
>>> int("123 890 123")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '123 890 123'
> Before we can select a function to convert a string into a number we must first pick a numerical type and before we can do that we must think real hard about how big of a number we're going to support in this applicationAren't you doing the exact same thing in Python by picking `int()` over `float()`?
> what type of string are we going to get from the command line?
Well, this might be the case for system languages, but most have a single `String` type.
Here is the program you described in Python
def main():
n1 = input()
n2 = input()
sum = int(n1) + int(n2)
print(sum)
And here it's in Haskell main = do
n1 <- getLine
n2 <- getLine
let sum = read n1 + read n2
print sum
Accepting a single line of numbers is not much different main = do
nums <- words <$> getLine
let res = sum $ map read nums
print res
I didn't think much about it, it's not a lot of code and I guess it's easy to reason about?If you need that logging for debugging then you should use `Debug.trace` though.
I think that this presentation from Netflix engineering team is still the best demonstration of how productive you can be wit RxJS: https://youtu.be/FAZJsxcykPs
I'm going to borrow that one mate.
So true. The company that is able to do so will have such an advantage over the competitors it won't even be fair. I sure as hell will be developing apps for such device. Potential is unlimited
Hard disagree. The Haskell abstractions in the standard library are (mostly) great. Classes like `Monoid` or `Functor` as as basic as they get (in the sense that they describe a very small set of behaviors) and include laws.
Of course, user defined classes can incur in high cognitive load, but that is applicable to any language that supports abstraction.