Graydon Hoare

403 until you go to https://graydon2.dreamwidth.org/ first with JavaScript enabled and temporarily allow third-party scripts from awswaf.com.

Local reasoning is the foundation of everything formal (this includes type systems) and anyone in the type-system-design space would know that. Graydon Hoare (ex-rust dev) wrote a post about it too (which links to another great without-boat's post in the very first line): https://graydon2.dreamwidth.org/312681.html The entire point of having a static-type-system, is to enable local reasoning. Otherwise, we would just do whole program analysis on JS instead of inventing typescript.

As a programming language - I mean it seems cool but it doesn't seem like much of an innovation when things like Granule, Idris, Unison, Erlang, and more already exist. I want to take a moment to look at the Metaverse angle. If there is going to be a unique programming language for the metaverse, I think it's not going to be textual but instead is going to primarily be a 3D language. This poses a big challenge for a VR language because text is great[1]. The point of making it 3D would be that you are somehow capable of transmitting more information via the higher-bandwidth channel of the human visual cortex than you are through text. If you aren't making a 3D programming language, well then it might be a cool programming language but I don't know what it has to do with the metaverse. [1] https://graydon2.dreamwidth.org/193447.html

I subscribe to this and: > "The Not Rocket Science Rule Of Software Engineering: automatically maintain a repository of code that always passes all the tests" https://graydon2.dreamwidth.org/1597.html Intermediate commits to produce a pretty history while not passing the tests reduce their usefulness to about zero.

This is the one true way to do things, of course (https://graydon2.dreamwidth.org/1597.html), but besides the "why not use bors/homu" question - what prevents GitHub or GitLab from building this in? I hope we get to a world one day where a standard feature of all pull-request-ish platforms is that merges end up on a task queue, CI runs on the merge, and the merge only happens if CI passes. It doesn't seem like a terribly difficult feature to build in and the potential UX seems much nicer - e.g., just like there's "squash and merge" and "rebase and merge" buttons and the repo admin can require them over normal merges, there could be an "enqueue for merge" / "enqueue for rebase" / etc. button. (Maybe your goal is to get us to that world via acquisition, which would be great!)

This reads like a promo piece for these companies. It's been tried many times and hasn't worked. As a developer, I'd love anything that makes my job easier, but that usually is more control and explicitness. I think "always bet on text" is a more accurate future: https://graydon2.dreamwidth.org/193447.html

If you subscribe to the idea of a division of labor between systems and scripting languages, then Python + its C based extensions (Cython, Numpy, etc.) is ideal, as it already has an extensive scientific ecosystem. Julia combines the two in a single language. See this blog post and the one that follows it: http://graydon2.dreamwidth.org/3186.html

That's a great article, and the sequel on "Goldilocks" languages like Lisp & Julia appeared last week as well: http://graydon2.dreamwidth.org/189377.html An overview with excerpts also just appeared on LtU: http://lambda-the-ultimate.org/node/4990

>And some languages learned the right lessons from the coloring problem. For example, Go deliberately chose goroutines over async/await, accepting a heavier runtime in exchange for no function coloring at all. Java’s Project Loom (virtual threads in Java 21) made the same bet: lightweight threads that look and behave like regular threads, so no code needs to change color. The Loom team explicitly cited function coloring as a problem they wanted to avoid. >Zig went further: it removed its compiler-level async/await entirely and rebuilt around an Io interface parameter that i/o operations accept. [...] Though some argue that the Io parameter itself is a form of coloring. >Language designers who studied the async/await experience in other ecosystems concluded that the costs of function coloring outweigh the benefits and chose different paths. Green threads with a heavier runtime isn't the "right" lesson. Instead, it's a fundamental tradeoff of no-function-colors-ergonomics vs maximum performance. Some simply don't want to pay the "performance tax" or "interoperability tax" to avoid function coloring. The following is copy-paste of previous discussion links and added Wayback Machine links because lobste.rs is often down. Anyone who thinks Golang made the "right" decision should read why early Rust developers tried green threads and abandoned them. The revised conclusion is that Go's design is a tradeoff that works for their devs but not for Rust. The author of this…

> Or do people use it for coding too? Over time, you may discover one of the biggest truth about computing - the immense (and sadly disregarded) value of plain text¹. Code is nothing but structured text. The cardinal job of a programmer is text manipulation. I'm reading this thread in my editor. Why? Because I'm dealing with text - browsers are great for presentation of text, not so nice for manipulating it. What kind of manipulations? Well, I can find, narrow, collapse/expand, translate, extract summaries for paragraphs, find all the URLs (including matching a pattern), etc. Good luck doing all that in the browser - even with the extensions. Most developers don't even get annoyed by seemingly small things. Like how often do you need to bring the url of a given browser tab into your editor? Simplest thing, yet do it dozens of times a day and it gets vexing. For me - it takes milliseconds and a keypress - it even extracts the URL description and converts the link to markdown (if needed). Or another example - whenever someone's screen sharing, or I'm watching a video and they show a piece of text (let's just for consistency say a url). How would you normally extract it? e.g, for your notes. For me - it takes selecting a region of screen and a keypress - my editor calls a CLI OCRing tool and voila. I don't really care that the source isn't "technically speaking" text - if I can read it, then computer for sure can "read" it too, am I right? That's text manipulation. There…

Rust has concurrency issues for sure. Deadlocks are still a problem, as is lock poisoning, and sometimes dealing with the borrow checker in async/await contexts is very troublesome. Rust is great at many things, but safe Rust only eliminates certain classes of bugs, not all of them. Regarding green threads: Rust originally started with them, but there were many issues. Graydon (the original author) has "grudgingly accepted" that async/await might work better for a language like Rust[1] in the end. In any case, I think green threads and async/await are completely orthogonal to data race safety. You can have data race safety with green threeads (Rust was trying to have data-race safety even in its early green-thread era, as far as I know), and you can also fail to have data race-safety with async/await (C# might have fewer data-race safety footguns than Go but it's still generally unsafe). [1] https://graydon2.dreamwidth.org/307291.html

403's until you go to https://graydon2.dreamwidth.org/ first

Ah, but you’ve moved the goalposts! The original claim was that wasm would replace JavaScript. Now you’re just talking about wasm being another option from JavaScript for web development. This distinction really seems to matter to some people. I suppose there’s something tribal about it. Is rust here to destroy C++? Rust gets a lot of irrational hate in the C++ community, and I think this perception is the reason. Is Fuscia here to destroy Android? To some, this will be a very emotionally important question. > Yeah citation needed. The very first compiler release already described it as "a strongly-typed systems programming language (…)” This is the article I’m thinking about, titled “The rust I wanted had no future”. Well worth a read: https://graydon2.dreamwidth.org/307291.html > Performance: A lot of people in the Rust community think "zero cost abstraction" is a core promise of the language. I would never have pitched this and still, personally, don't think it's good.

> "Rust isn't designed for efficiency" Citation needed, because Graydon Hoare the original Rust creator (who has not been involved with Rust development for quite a long time) wrote about how the Rust that exists is not like the original one he was designing: - "Tail calls [..] I got argued into not having them because the project in general got argued into the position of "compete to win with C++ on performance" and so I wound up writing a sad post rejecting them which is one of the saddest things ever written on the subject. It remains true with Rust's priorities today" - "Performance: A lot of people in the Rust community think "zero cost abstraction" is a core promise of the language. I would never have pitched this and still, personally, don't think it's good. It's a C++ idea and one that I think unnecessarily constrains the design space. I think most abstractions come with costs and tradeoffs, and I would have traded lots and lots of small constant performancee costs for simpler or more robust versions of many abstractions. The resulting language would have been slower. It would have stayed in the "compiled PLs with decent memory access patterns" niche of the PL shootout, but probably be at best somewhere in the band of the results holding Ada and Pascal." https://graydon2.dreamwidth.org/307291.html

Whenever I see things like this I tend to think back to this: > Largely I think that text is already a highly-structured graphical notation, and that when people try to get "away" from it they're often doing so from a position of ignorance of how very long it took to get to where we are in textual notations, and how very many technical innovations are latent in textual notations. Visually unambiguous yet uniform symbol sets, combinatorial-positional word formation, linear spatio-temporal segregation, punctuation and structured page layout .. these are all technologies in writing that we had to laboriously invent, and they have purposes, advantages! Similarly in coding, we had to invent and adapt technologies from verbal and mathematical notations refined over millennia: lines and columns, indentation, block layout, juxtaposition and precedence, scope, evaluation order, comments, grammars, version control, diff and merge algorithms ... the pile of structuring technologies embedded in the textual representation of programs isn't free, and it isn't useless. So I'm just really cautious when people suggest throwing it all out for some hypothetical reinvention. You need those structures: so you've got an immediate problem of "what are you going to use instead", and a longer-term question of "what makes you think you're not going to wind up right back at the same place ten thousand years of refining graphemes-on-a-page wound up"? (Taken from https://graydon2.dreamwidth.org)

I skimmed your blog post, and I'm not quite sure I understand how it will make editing easier. It seems more complex to me, although that might be because it's unfamiliar. If you want some intelligent counterpoint, here is a post by the designer of Rust on why text is a good representation for programs: Always Bet On Text https://graydon2.dreamwidth.org/193447.html As someone who's working on a programming language, and has implemented a few DSLs and many parsers, I tend to agree with him. Parsing is a pain in the ass, but I think it can made easier. The difference between text and structured data is "just" parsing, so I don't feel that switching to structured data can be a real paradigm shift. If there was a paradigm shift to be found, then it would have been implemented already by converting text to structured data, and operating on that data. And this of course already happens in dozens of IDEs, and that's great, but it already happened. And while I have seen people be fantastically productive in IDEs, a lot of the best programmers I've seen also use emacs/vim. But your ideas do seem more fleshed out than most, and I think that developing a prototype is the only way to make them more concrete, and more clearly see the benefits and costs. I do think there are benefits to making structured data the primary format -- I just think they are outweighed by the costs. Graydon's post outlined a bunch of things you lose if you abandon text.

I still can't believe that there are people who actually think VR is going to be used by anyone besides people who play video games. I've used an Oculus, and I've used a Vive, and I've used a Google Cardboard, and I've tried all sorts of neat demos. I fully believe a photorealistic experience can be had, and I fully believe that that experience will be able to exist at a reasonable price point, but I don't believe normal people will be interested in such an experience. As a medium, it's not nice to use with other people, which is a huge part of the way we consume our media. I don't believe that normal people are going to ever socialize by looking at each others avatars. If you consider interacting with someone's avatar socializing, you should understand that is why people make jokes at the expense of World of Warcraft players. Once the novelty wears off, people aren't going to find it interesting. It's not great for text either, and I don't think it will ever be better than a 4k monitor for text... Always bet on text. http://graydon2.dreamwidth.org/193447.html I agree that AR could be huge. But VR gets way too much hype.

Text is Lindy. It has withstood the test of time and it's as ubiquitous as SQL or TCP/IP. Reminds me of this decade old post (and discussion) by Graydon Hoare, "Always bet on text". [1]: https://news.ycombinator.com/item?id=8451271 [2]: https://graydon2.dreamwidth.org/193447.html

I wonder how relevant and feasible this workflow would be: https://graydon2.dreamwidth.org/1597.html Where you have two repositories, one "polished" where every commit always passes, and another for messier dev history.

Rust was created on a Mozilla payroll to provide a C++ alternative with better concurrency support for the purpose of browser engine rewrite. Also, Rust doesn't have a 'creator', the person tasked with leading the project didn't have the authority to make the decisions, see https://graydon2.dreamwidth.org/307291.html

Rust's original author agrees with you: https://graydon2.dreamwidth.org/307291.html

It is 2025 and CSVs still dominate data interchange between organizations. https://graydon2.dreamwidth.org/193447.html

You're kind of inferring the inverse argument to what I pointed out. I believe in healthy discussion and along with the original creator of Rust I agree that there are plenty of things Rust didn't solve [1]. Nor do I believe that Rust is the perfect tool for all tasks. It's a good tool for a significant chunk of problems. That's where I stand. That said, equating people arguing in bad faith to any form of disagreement. Sorry here we disagree. [1] https://graydon2.dreamwidth.org/253769.html

Rust’s “mutable-xor-aliased” model makes it particularly amenable to developing verification tools on top of it [1]. Without this model, verification becomes just as hard — and just as practically intractable — as all the verifiers for existing languages. 1: https://graydon2.dreamwidth.org/312681.html

Fwiw I don’t think your parent is lying but I also don’t feel it’s really accurate. If you read https://graydon2.dreamwidth.org/307291.html for example, there’s some references that imply this, but it’s not really that “less symbols” was a goal so much as it is a secondary effect of other choices. Graydon wanted a simpler language and that implies simpler syntax, not the other way around. Even the grammar bit isn't really about "symbol soup." Early Rust had other sorts of things that a lot of folks would consider readability problems unrelated to symbols too: no keyword was allowed to be over five characters, so return was ret, continue was cont, etc.

> the merge commit also wouldn't be tested Why wouldn't it? This is the "not rocket science" rule of software engineering: every commit must pass the tests. There's no special exception for merge commits. https://graydon2.dreamwidth.org/1597.html

> "No invisible magic" was a promise that Rust made to us. Honest question, where did you get that promise from? The 1.0 release didn't really emphasize that: https://blog.rust-lang.org/2015/05/15/Rust-1.0.html The current rhetoric is more about empowering more people to have confidence in systems programming: https://doc.rust-lang.org/book/foreword.html Some of graydon's ideas starting almost a decade before 1.0 might have included that https://github.com/graydon/rust-prehistory/blob/df8cc964772b36fe120df5… but his recent posts on what he would have done differently if he was BDFL include a bunch of stuff that's arguably more magical, not less: https://graydon2.dreamwidth.org/307291.html

This is not how YouTube, or people, or virality work though. The fact there is some useful educational content is a byproduct of the machine of lucrative trash of the capitalist hellhole spiral, and the written word will always prevail comparatively. You can always bet on text. https://graydon2.dreamwidth.org/193447.html Also, as you likely know, YouTube is owned by Google so it’s very silly to say it’s “more important.”

if you have a problem with gnu/linux (as opposed to android) you can usually find the solution on stack overflow, server fault, or superuser, but the solution you find there is going to be a textual command line, not a gui. gpt-4 can tell you how to solve the problem, but only using a textual command line, not a gui. text is the most powerful, useful, effective communication technology ever, period. always bet on text: https://graydon2.dreamwidth.org/193447.html https://news.ycombinator.com/item?id=40909185 documents that this is actually also true for microsoft windows on the other hand, 'always bet on text' doesn't mean 'always bet on editing your command line with inconsistent control-character commands in a mode where clicking with the mouse doesn't do anything'

Always bet on text (http://graydon2.dreamwidth.org/193447.html and on HN at https://news.ycombinator.com/item?id=8451271) But really. Always, always bet on text. Chances are it'll work in 10000 years if we still exist.