True. Probably, only AWK is an exception.

And Lua

I’d think this actually applies to nearly everything in software and is def a useful thing to keep an eye on.

Underemployment for the last 3 years has given me a great opportunity to dive deeper into a lot of CS topics for things we use daily and read (or at least try to read) specs and code bases etc.

I’ve come to firmly believe that languages or other open source projects that get popular, usually do so for the things that are in its early versions.

For example, the HTTP 0.9 spec is like 1 page. UDP is like 3 pages.

I’d seen an article on HN recently (cant remember the name) that described this well. A language or what not starts simply and many jump on the bandwagon. Then starts adding incremental features, none of which are difficult to incrementally learn for existing users but the footprint of the product keeps expanding. C++, Javascript, Web APIs, graphics languages like OpenGL all are examples in my eye.

The fact that our system (broadly speaking) incentivizes inventing something ‘new’ rather than fixing or simplifying an existing something certainly exacerbates this.

When I try to explain this to non-programmers I often use this metaphor: Imagine that you enjoy mountain climbing, but the act of climbing the mountain causes more mountain to rise above you.

That's what we see in software development: a runaway process of elaboration and ever-increasing complexity and levels of abstraction.

Lua has done pretty well to avoid this IMO. Notably they added coroutines with basically zero cost to the implementation (essentially just a pointer keeping track of function position on top of the already existing closures). The whole language is incredibly constrained yet powerful

>I’d think this actually applies to nearly everything in software and is def a useful thing to keep an eye on.

Sort of like if the Peter Principle and Parkinson's Law had a child.

https://en.m.wikipedia.org/wiki/Peter_principle

https://en.m.wikipedia.org/wiki/Parkinson%27s_law

Or just Zawinskis Law:

https://en.m.wikipedia.org/wiki/Jamie_Zawinski#Zawinski's_La...

1. Dynamically typed!

2. Ok that didn't work too well we've added static type hints.

Does anyone know of any good embedded statically typed languages? It seems to be a very unexplored design space. The only real ones I know of are AngelScript (which catastrophically fails rule 0 of programming languages) and Gluon which is just a bit too weird and aggressively functional for me.

What's rule 0?

Show examples on the main web page.

Try and find an AngelScript example. It's stupidly hard. Compare it to these web sites:

https://dlang.org/

https://koka-lang.github.io/koka/doc/index.html

https://vale.dev/

http://mu-script.org/

https://go.dev/

https://www.hylo-lang.org/

Sadly Rust fails this too but at least the Playground is only one click away. And Rust is mainstream anyway so it doesn't matter as much. I completely failed to find a single AngelScript example accessible from my phone's browser. Even its Wikipedia page doesn't have any.

I made a prototype that works in 3000 lines of C

github.com/civboot/fngi

It was super fun. I'm going to be going in a different direction (Lua implemented in Lua, with Lua-library assemblers and assembly type system), but it's certainly very possible

Nice! Pretty interesting syntax. Not sure about / for comments or the function argument syntax but you have a solid point about not using " or ' for strings!

Thanks :)

FYI the real power of / for comments is /token to comment out one token. So useful to add a bit of doc sugar when calling something

    call(x\sugar)

    call(x/*sugar*/)

Also

    Thing \(inline comments) other

Perhaps Roblox's Luau? It is Lua with gradual types and a sandbox-enabled VM [1]. "Luau aims to be backwards-compatible with Lua 5.1", so yep, still 1-based array and string indexing :-).

--

1: https://luau-lang.org/sandbox