Dot-dev domains

[qwertie]

Today, Google .dev domains became available at non-premium prices. I added mlsl.dev (Multi-Language Standard Library) and idesign.dev (interface design) to my cart. Guess I'll get out my credit card...

Google charges a large premium for three-letter domains and common words... with that in mind, I wonder if it's worth buying anything else. So @jonathanvdc, let's say you or I make a new programming language someday and it has to be four characters long and can't be a common word. What could we call it and why?

[qwertie]

"The Google Domains service can only be used for business or commercial reasons in your current country." Err... wtf? I think it's talking about Google Domains itself and not .dev...

[qwertie]

Okay, given that my general idea is to figure out how to translate superior or more general PL features into languages with fewer and more limited features... I think I found a good name: TOFF.

• Translating Onto Flawed Foundations
• Traduciendo Obras en Fundaciones Fatales

(It seems like if I claim to be able to translate code between languages, I ought to be able to at least translate its acronym. Maybe the Spanish version reads a bit too strong though: "translating works into awful foundations")

[qwertie]

Or...

• Old languages, new abilities
• Otras lenguas, nuevas aptitudes (word order incorrect?)

[jonathanvdc]

Wow, I didn't even know .dev was a thing

Toff sounds like a cool name for a programming language. Maybe it's a bit similar to troff, but that's a typesetting language so that shouldn't cause too much confusion. Toff is also a pre-existing word, so that's a plus as well. (Although it is a bit of a derogatory term.)

I don't think Olna sounds as cool as Toff, but that's just a personal opinion.

[qwertie]

If the name is good, we just have to figure out how to support all features in all languages. This is, of course, hard and requires a lot of thought. Just a few issues off the top of my head:

• Open and closed union types (traditional ADTs are closed union types - how to support open unions on langs with only closed unions?)
• Go-style interfaces in languages with Java-style interfaces... I implemented a good prototype of this for C# already in a CodeProject article a few years back, but the runtime overhead is significant and I'm not sure if it would work for all languages. Something like this is probably very important though; for example, in a properly-designed language you can treat a "string" as a real-only list of characters - ideally they'd be the same type - but in .NET, strings and lists are totally different types and don't even share the same interface (except IEnumerable!char which certainly isn't a complete interface.)
• Supporting structural typing in languages with only nominal typing... my current idea for this is to support structural "records" which are ordered records translated to tuples and thus act structurally. Nominal types would also be supported. So you could write record Foo { x:int; y:int; .fn sum()=>x+y; } to create a class based on tuple!(int,int), or class Foo { x:int; y:int; .fn sum()=>x+y; } to create an old-fashioned nominal type.
• Different degrees of genericity... I'm playing with the idea of three kinds of genericity, Java-style, C#-style and D-style, which confer different levels of power (Java = type erasure, least capable; C# = reified by runtime, preserves interoperability with existing C# code; D = very powerful, but requires the compiler to pre-instantiate every supported set of type arguments, so for example plain C# code cannot instantiate the generic class/function with new type arguments.)... in this regime, a less-powerful generic cannot use/call a more-powerful generic.

Not sure how to find the time to actually solve these problems and the other 42 that will inevitably come up.

P.S. haven't figured out which registrar to use either. My old registrar seems to support .dev but at a significantly inflated price. If I actually did have a business model, maybe I could afford that...

[qwertie]

I've been thinking though... that maybe a master language aka "toff" isn't the first step... maybe even the MLSL isn't step one... but just something to keep in mind while figuring out step one.

There is a neat language under development called Unison, designed to make distributed computation easy by making code portable... This Haskell-like system will distribute code among machines for you so that you can write a distributed system as though it were a single program.

That's a pretty killer feature. Would be a shame not to have something like that in a "master language".

So I was thinking that maybe step one is to help figure out how to make code more portable (across machines, or at least in the sense of making code-as-data easier) while maintaining high performance and achieving cross language interoperability. I think the ideal way to do this is that somebody hires me/us to help design webassembly and then we design a really fantastic substrate for putting any other programming language on top of it, and then after that we design an interop layer and a small but powerful and general language on top of it, which becomes the new Lua, so you can use it as a library, and then maybe I revisit this toff idea ten years later.

But this step one is fatally flawed because probably no one would be willing to hire me to work on webassembly, not even for half market rate. So, scratch that.

But hey, maybe it can be done in reverse. I design the Toff, then we figure out the standard library for it, but someday it will support LLVM as a target, and have compilers for every OS, which are easy to invoke programmatically from many popular languages, at which point it becomes the new Lua, which somebody else turns into the basis for a distributed programming system? Okay, probably won't happen, but a guy can dream.

Loyc just needs more manpower and money. Pretty hard to make an ultimate programming language otherwise. But as yet, none is foreseeable. Perhaps the only option is to start some kind of business... but that's soooo not my thing.

[subnut]

Off-topic

Hey @qwertie

"The Google Domains service can only be used for business or commercial reasons in your current country."

Were you able to figure out what that text means? Did you face any difficulty till now?
Actually, I also saw that warning while registering a domain on Google Domains.

A quick DuckDuckGo brought me here 😅

[qwertie]

@subnut no, I didn't find out why Google says that. I haven't registered the domain I wanted to, either.