you know Godel’s Incompleteness Theorem? The idea that any consistent formal system is incapable of proving all truths?

I think that I believe that something similar exists for formal type systems: for each of them there are concepts that are useful but inexpressible

anyways Rust’s type system has conspired to make something that seems like it should be simple: async functions in object traits - seemingly impossible, and apparently this remains an unsolved probelm

https://smallcultfollowing.com/babysteps/blog/2019/10/26/async-fn-in-traits-are-hard/

Support for async fn in traits is probably the single most common feature request that I hear about. It’s also one of the more complex topics. So I thought it’d be nice to do a blog post kind of giving the “lay of the land” on that feature – what makes it complicated? What questions remain open?

uh, suffice to say, the fine details of this intelligent strangers’ blog entry mostly go above my tiny peanut head and I just read “it’s stupendously difficult for a lot of complex type safety reasons, and there’s a macro that makes it possible using devil magic”

In general, this seemingly benign idea: “i’m going to define my service interfaces as traits and then I can implement the backend using swappable services that each implement the trait”

has felt like a bit of an uphill battle in Rustland

for me it’s the funny crab

i’ma say it, now that I can program in Rust, I can’t imagine a scenario in which I would want to program in Go

the tow capacity of a Miata is a sternly worded note in the manual saying “no”

“do not do this, it is an extremely bad idea”

of course, most folks on the internet perceive that as a challenge which is why there are loads of pictures of Miatas towing things, presumably out of spite

This might be one of my more controversial opinions, but…

JavaScript doesn’t benefit much from having a whole-ass type system bolted on a la TypeScript. It’s like attaching a tow-ball hitch to a Miata: just adding the capability doesn’t make it practical to use. JavaScript is not the right environment for type safety.

If you want byzantine type safety, just program in a language that was designed from the ground up with byzantine type safety in mind, like Rust, or C#, or Scala.

the thing I like about javascript conferences is that they only have one room for talks but they just get whoever’s on the mic at any given time to hand it over when they need time to set something up, so you can quickly catch loads of talks so long as you don’t mind that they’re in kind of a jumbled order

the thing I like about C conferences is that if you find the end of a line and stand two spaces behind it, the building will explode

the thing I like about Erlang conferences is that if anything goes wrong in one of the rooms, everyone will just leave, get back into the room, and pretend like nothing happened

i can’t remember what I liked about memcached conferences because there was a power outage

the thing I like about rust conferences is that they’re a huge amount of effort to set up but once they do they run really smoothly

the thing I like about PHP conferences is that they’re easy for anybody to set up and that it’s really hard to predict what will happen at them, which is also a thing that a lot of people do not like about PHP conferences

the thing I like about Go conferences is that they’re exactly like C conferences, but with a guy who comes around and collects the garbage every now and again

the thing I like about Postgres conferences is the consistency, but they only ever throw the one and honestly if they can’t find a bigger venue they’re going to start running out of space

i’m not such a big fan of AWS conferences, they seem reasonably priced at first but then you wander from one region to another and suddenly you owe them fourty eight thousand dollars

i’ve never managed to get in to a RabbitMQ conference but I’ve had a great time just waiting in line for one

I wasn’t sure which mastodon conference to attend, there were so many and most of them seemed like they were run by amateurs, so I just went to the biggest one

the thing I like about lisp conferences is that there aren’t a lot of standards or guidelines for them so each of the big ones just kind of makes up its own rules

the thing I like about retro emulation conferences is that you go into a huge, modern conference hall and they’ve set up a perfect recreation of a conference from 1993 in there, all the way down to the carpeting

the thing I like about roguelike conferences is that if you miss a talk you just have to leave

the thing I like about VC-funded conferences is how fun they are in the first few years, before they inevitably need to justify their massive investment and start to get weird

the thing I like about C# conferences is how much they improved over Java conferences, which they were clearly modeled after, but honestly I haven’t seen or thought about either in years and I think I’m a lot happier for it

the thing I like about scrum conferences is that they’ve clearly never put any more than two weeks worth of effort into planning them so they’re always just all over the place

(I would, of course, refuse to attend any scrum conference that took more than 2 weeks to plan: that would just be a waterfall conference and who wants to go to one of those?)

I attended a pure functional programming conference and as a result I changed my mind about functional programming, which , when I think about it, means it can’t have been a pure functional programming conference after all.

The thing I like about quantum computing conferences is that they’re run in a lot of different states at the same time

The thing I liked about AI conferences in the 80s were that you could set your booth up in a part of the conference hall that nobody could get to, and, in doing so, bring the entire convention to a halt.

me: Result is acting strange, it has different behavior in this example than in my code

r/rust: which Result were you using?

me: what do you mean, which Result?

one of the significant barriers I have to learning Go is just how mad it makes me

I love all languages equally.

mutable slices? string length determined by raw byte count of the UTF-8? pointers to mutable data as arguments?

i’m sorry, are you from the past?

Go’s whole community seems to have unified around a convention of single-letter variable names which is as infuriating as it is simply wrong, and the dank ass Unix wizard responsible should be retired for it.

I don’t care if your hands are falling off your body and you’re still using vi, typing the rest of the word is STILL non negotiable

you ever try to grep the letter “l”?

you don’t need to write a whole essay but you’re not even bothering with the word

anyways: here’s what I think about that, in a language even you fucking Go nerds can understand: y c g f y

words are free my good bitch

look at me, I’m using a code editor written in 1974 so I can’t simply autocomplete any variable name by pressing tab

look at me, I think that writing code is more important than reading it

Now Rust - Rust is a thing of beauty.

I’m angry at myself, for being too stupid to think seven-dimensionally enough to be able to code in Rust. Oh, the type of that code is a Maybe[Future[Async[Wrapper[Arc[Reactor[Core]]]]] and you needed a Future[Async[Arc[Wrapper]]]]? Guess you’re fucked.

But with Go, I’m angry at the language, just for having the sheer gall to just be C with a rubber mask on.

Learning Rust is like learning Haskell, or, like, Esperanto, it’s a mind-expanding paradigm that’s endlessly frustrating because you’re learning how to operate in a new, fae universe where the rules are as alien as they are unbreakable, and while you respect its beauty and power, you literally can’t do anything because you need to spend 6 more Lifetimes learning about how Hindley-Miller type systems apply to memory management.

Whereas learning Go is more like driving a manual transmission to the Staples so that you can send a fax to your doctor. You just spend the whole time going “fuck, it’s 2023, I can’t believe I still have to do this shit.”

just wanna emphasize that one time I spent a whole afternoon reading about how one might attempt to build a linked list in Rust and I still don’t understand how to build a linked list in Rust

somebody wrote an entire book about how to write a Linked List in Rust

the memory safety aspect makes it slightly more complicated than building something trivial and dumb like a working nuclear reactor or an entire commercial jet

Editor’s Note: years later, I finally learned enough Rust to be dangerous and it is one of my favorite languages. On the other hand, this blog is running on Hugo (Go) and when I realized that Go HTML templates use, essentially, postfix notation, I got so mad I threw my mug at my computer screen.