InsanityBit

Claude is far too nice and not nearly as skeptical as I want it to be. I suppose second guessing and checking assumptions is very expensive but it's frustrating, and I've found that I need to have a second model in a sort of "skeptical mode" to compensate.

did the same thing for a toy language recently - I had a few restrictions on returning borrows and storing them, but otherwise it was no-gc safety with no borrow checker.

I'll look forward to what you come up with.

Extremely common tactic in pseudo science and misinfo. It's even common in really fringey nutty stuff like flat earth arguments.

Safer Drivers, Stronger Devices | Microsoft Community Hub Surface is advancing Windows driver development by adopting Rust, a memory-safe programming language, to improve device security and reliability. Through...

Safer drivers, stronger devices (with #rustlang)

techcommunity.microsoft.com/blog/surface...

OpenAI's Codex needs a lot more work.

Very glad that "function coloring is good" has stopped being such a hot take.

I wonder how much ChatGPT usage spikes on Prime Day

Oh, in the case before X and Y are individual types, Point is its own type. So the generated code is just moving the struct fields of X an Y into Point.

No implicit nullability.

Hm, not sure what you mean then. I do have struct fields, not just methods, or I'm misunderstanding.

Support for atoms is now implemented.

Might do generics later but for now I'm hoping to avoid it and I think with overloading, variadic tuples, inference tricks, comptime, etc, I can get something good without it.

Also, I'm hoping to avoid generics using features like this + others.

Like, you want a thing with fields x and y? Take a `Point`, and if someone wants to pass in `MyPoint` they can do `{..my_point}` and it'll work fine (and be 0 copy if `my_point` is not used again)

My hope is that the capability system gives enough opportunity to open up novel optimizations + ability to 0-cost trivially inline Rust will cover the rest.

This is a GC'd language, so no direct access to pointers (but you can write rust inline if you want that). There's mutability semantics but ultimately it leans hard on CFG-analysis to optimize as much as possible + gives rust as escape hatch.

I may end up allowing for some sort of scoped anonymous structs that can't be passed to functions but could be used to elide the X and Y here, and eliding Point would be done via inference whenever Point gets passed into a fn. So some combo of inference and restrictions may end up being right UX.

rust code doesn't compile, afaik it can't

my lang compiles tho

I hadn't! I thought there was a lang proposal for something like this but didn't know there was a crate. Interestingggggg.

This + another idea I had may be what I need, although for now I went with a superpowered spread operator.

Running into a particularly challenging issue. I want anonymous structs in my language. Doing this in a way that's zero cost + compiling to Rust is *hard*. In particular, the first pass I have is to gen `HasX` traits for each prop, but then rust borrows the entire `self`, making moves impossible.

I can know that functions are pure, when they allocate, etc. I can track aliasing, 'last use', etc. It's valid for my language to consider allocations side-effect free, which I don't think is the case in Rust/ LLVM IR.

I also track integer value min/max via a CFG and prellocate based on them.

My language is now faster than rust... sometimes.

Faster default hasher + the effects system opens up novel optimization opportunities.

got capabilities done

Also, the language supports writing inline rust so if you really want that full rust perf you have it available to you at any time.

Integer operations are basically as fast as Rust in the common cases so that's nice, it's objects, especially deeply nested objects, where I need to rely on optimization passes.

Thankfully my language has pretty rich types.

Spent time writing some basic optimizations for codegen. I've doubled the performance of some operations. Still much slower than Rust, but I'm about to write a CFG to do a lot more optimization. And there's still low hanging fruit.

My language now supports inference of union types in a way that's really neat and compiles to a rust enum under the hood. Full Hindley-Milner with unification, lots of type tracking info that I may use later like *where* a type comes from (for flow typing and refining later!).

Anyone aware of good type system stuff for GC'd languages that track mutable vs immutable references? Seems like you basically end up with regular reference types + specially marked "unique" types where unique types have tracked references.

Writing this programming language and documenting it all as I go. Then I give cursor a prompt to try learning the language from docs and generate test projects as it goes, validating every bit of documentation.

Either it finds bugs in the docs or bugs in the compiler, extremely helpful.

Time to try to give my programming language reference types.

I've always used it, literally since like... middle school papers. I can find so many old blog posts from 2012 that are absolutely full of them. web.archive.org/web/20150205...

Just a random wayback and there are 4 right there.

Some neat things that make it a happier dev UX than Rust.
1. List and map comprehensions.
`let numbers = [1, 2, 3, 4, 5];`

2. Inferred union types.
`let mixed: List<string, bool> = ["test", true];`

3. Limited borrow check (can't return refs but no lifetimes to manage):
`fn takes(foo: &string)`