ChubbyGlasses

This was my biggest problem with rust, the community is, at a surface level friendly, but the moment you try to say something against the grain you get met with some of the most insufferable people ever. I tried to mention a problem with a lint on the official forms and the replies were so condescending (from regulars at that too). And at no point did they try to understand the issue, they just assumed I was dumb/new/doing something wrong.

I've had very similar experiences on Windows and Mac. I really wish Moz would fork WebKit or Blink and work on a browser for the modern age.

I like FF as much as the next person and have been using it as my daily driver for a while now, but FF doesn't hold a candle to the responsiveness or snappiness of Chrome. It's especially noticeable on content or media rich sites where FF crawls down to a halt. The general browsing experience is nowhere near as good or refined as Chrome's, but when there's literally no better option you kinda just have to suffer through a sub-par browser.

More and more I've wanted a browser based on WebKit/Blink from a company with the original Mozilla's values. I know this will get a lot of flack, but Gecko feels way too antiquated for what I want out of a modern browser. Not to mention, browsers are significantly complicated that splitting developer efforts just doesn't seem like a good idea; Firefox keeps falling further behind in term of modern features.

idk about a "war" or we, but features aside, zig feels like a less obnoxious language, and i mean that as politely as possible. to make an analogy, rust is like a friend that constantly nags about _everything_; like you know they mean well, but girl chill i know. about to cross a street, rust reminds you to look both ways. empty street with no cars around and it's safe to cross, rust wont let you cross until the crosswalk sign lights up. cooking something, rust will pester you about proper knife safety. like yes i know, being a nuisance about things i already know about doesn't help me write better software; i already know to look both ways before crossing. every once in a while it catches something you wouldn't have otherwise, but you have to deal with that constant pestering _all_ the time. also, just my personal opinion, but rust has some of the worst language ergonomics i've seen in any modern mainstream language and i don't think it can reasonably be fixed due to its 1.0 promise

I loved the show and picked up the book afterwards (still working my way through it), and ya I think you're right to some extent, but the show feels more additive than reductive; the book, as it is, would not adopt well for television, and the more human stories felt like a nice addition for me without straying too far away from the book's story. Arrival felt like it was in a similar boat where it was adapted for the movie-medium and, IMO, much better for it.

i've been playing around with bard a little bit throughout i/o now and it's really good at getting the big picture but tries a little to hard to be vague when asking specifics (unless it's about code, in which case it's stellar, but that is less interesting to me).

i asked it to generate some code for something i've never worked with and it seems to do a good job, not perfect but good enough for me to get a running head start.

on the other hand, i want to try and learn french, but for the life of me, i couldn't get it to provide a good starter page for learning pronunciation and the basics. bard did a good job providing a basic learning plan, but not more than that.

first time using a LLM (chatgpt or otherwise) but it's been pretty neat if a bit limited rn. like everyone else has mentioned, i want the computer from star trek and would probably be willing to pay for for it if the value proposition was high enough (read give me "superpowers" i didn't have before, less about refining my existing skill set).

i always found this to be a strange pov to have on LLMs. imo, it's not humans tricking/gaming the ai, but rather chatgpt has tricked you into believing it's smarter than it actually is. (in human terms, chatgpt is just more articulate than llama)

it's a subtle distinction, but i think it shapes and reflects how you view ai as a tool for humans or as a replacement.

Swift and Carbon both seem like very strong contenders in this space. Swift is already a really strong language albeit a little too tied to Apple’s ecosystem. This along with the ownership manifesto slated for Swift 6 (and C++ interop) should make it easier to use it everywhere. In particular, I see a lot of value for tooling (eg JS code bundlers and such) that are rewritten in “thinner” languages for performance needs without sacrificing developer productivity.

Mine were mostly third party crates like bitflags and thiserror. Not saying that's what was effecting your build times, I'm not really familiar with your repo (my comment was only directed at my proj), but also it's pretty hard to write a significantly large project without macros; it's just the devil you kinda have to live with.

This is pure speculation, but I suspect egregious use of proc macros in Rust also inflate compilation times a bit. Just speaking anecdotally, but removing proc macros in one of my hobby projects decreased clean build by about ten seconds. Definitely not a couple magnitudes like the author saw, but not unnoticeable either.

> "match", "if let", "unwrap_or_else()", etc...

all different ways to write `if err != nil`, none of them are better than the other

> mapping/propagating an error

which is literally what i said "moves all your error handling logic to a separate file"

have you written any long-term maintainable code? comments like yours is why i've lost hope in rust and the community; you don't even understand the challenges large code bases face and yet continue with baseless zealotry.

Same, I was really hopeful that Rust was going to fill the void of a modern systems language (been following it since around 0.6), but judging by the direction it's been headed the since 1.0, state of libs and the ecosystem, and the general community sentiment, I've kinda lost hope at this point. To quote Carbon's readme, "barriers range from changes in the idiomatic design of software" (emphasis mine).

What took the cake for me though, was a post a couple weeks ago where people were griping about Go's error handling (if err != nil) when Rust is, at best, no better than Go (e.g if you want to add any context to your error), or just objectively worse off (? operator moves all your error handling logic to a separate, completely different part of your code base).

I think there are different ways to look at boilerplate, some of which languages like C++ and Rust are great at handling through their standard libraries, but there is also code boilerplate that needs language support handle well. defer and C-style for loops being the most well known constructs where the language provides syntax for something that otherwise would be difficult to express with just functions and lifetimes. Swift goes a step beyond by providing syntax for many other common patterns (aka boilerplate).

For example, a few areas where Swift reduces boilerplate and the syntax it provides to do so:

  - a complete null/optional story: first class optional types (T? = Option<T>), null chaining (obj?.prop), and null coalescing (T ?? "default")

  - error handling: fn() throws Err (= fn() -> Result<T,Err>), try, try?, try!, do/catch (out-of-band error handling), w/o stack unwinding, see nulls

  - and struct/enum lifecycle management: constructors, getter/setter props, defaults, named functions, named tuples, etc. (this list is loong)

Individually each feature is small and could possibly be argued as bloat or overhead since you can accomplish the same with just regular functions and Rust-like code and abstractions, but combined they make the language feel more expressive (and more fun IMO) than would otherwise be possible and often without sacrificing performance. They also serve to reduce cognitive overhead in the same way using for loops is nicer than desugaring to while loops. This is nothing to say of the syntax itself, and a bunch of other small features; Swift really is a case where the whole is greater than the sum of of its parts.