- the_gipsyWorks much better than desktop, but clicking back doesn't restore the scroll correctly, e.g. the link I clicked was hidden behind the header on return, disorienting.
- The irony is that you're still not discussing the font
- Cool work on a font, but this page is proof that google is turning the web into some kind of JSON for their app, Chrome.
Extremely sluggish on non-Chrome. Starts with a black blank empty page. Fans spinning. Takes way too long to load for just some text and some videos. Clicking a link does some SPA magic that takes me to another black blank page, and takes ages to load. Clicking back doesn't work anymore. I need to reload the entire page, again blank and waiting. Once done loading, scrolling is extremely sluggish.
Yes, there are probably some interactive widgets in there, but all that and much more has been done without bogging down the browser like you're running a 3D game on WebGL.
Oh, and of course reader mode doesn't work.
- Exactly. This is just a racket so that bad apps can "steal" downloads by getting in the way. The good apps then also need to pay the racket to fight the bad apps.
- We're on the verge of an unprecedented economic crisis.
- La li lu le lo?
- The president of the USA is on the equivalent alternative to Twitter.
- In my country I cannot buy a SIM card / phone number without giving my full identification.
- That's exactly what I read out of it. I should yave stopped midway.
- > not an actual tty
Hold up, this could be good
- Go ahead and do it!
- ...and if everything was wrapped in Option<>.
If my grandmother had wheels, she'd be a bike.
- I usually just `git rebase origin/main -i` after the base branch has been merged there, and this means I need to explicitly drop the merged commits, but I can inspect what's happening.
- Okay let's dissect that.
"Easily" doesn't mean "it happens all the time" in this context (e.g. PHP, at least in the olden days).
"Easily" here means that WHEN it happens, it is not usually obvious. That is my experience as a daily go user. It's not the result of copy-pasting, it's just the result of editing code. Real-life code is not a beautiful succession of `op1, op2, op3...`. You have conditions in between, you have for loops that you don't want to exit in some cases (but aggregate errors), you have times where handling an error means not returning it but doing something else, you have retries...
I don't use rust at work, but enough in hobby/OSS work to say that when an error is not handled, it sticks out much more. To get back on topic of succinctness: you can obviously swallow errors in rust, but then you need to be juggling error vars, so this immediately catches the eye. In go, you are juggling error vars all the time, so you need to sift through the whole thing every goddamn time.
- The go stdlib notoriously returns errors without wrapping. I think it has been shifting towards more wrapping more often, but still.
``` func process() error { err := foo() if err != nil { return err }err1 := foo() err2 := bar() if err1 != nil || err2 != nil { return err1 // if only err2 failed, returns nil! }
} ```if something { result, err := bar() // new err shadows outer err if err != nil { return err } use(result) } if somethingElse { err := baz() // another shadow log.Println(err) } return err // returns foo's err (nil), baz's error lost - "Context" here is just a string. Debugging means grepping that string in the codebase, and praying that it's unique. You can only come up with so many unique messages along a stack.
You are also not forced to add context. Hell, you can easily leave errors unhandled, without compiler errors nor warnings, which even linters won't pick up, due to the asinine variable syntax rules.
- I also code go daily for work, and while what you say is true, it's still far less than what I remember from working with Java, which was constantly wrapping mundane crap in classes and other stuff.
- You started it, where's your evidence?
- go's error handling is very poor and too verbose, but go is still way less verbose than Java overall. Like any other language.
Java is the running joke of verbosity, and you are too if you seriously argue that it's not.