#kittyscript

@whitequark@social.treehouse.systems @aeva@mastodon.gamedev.place it's a very simple and minimal language that still has all the necessary building blocks to build anything more complex on top of it, except for multi-threading. (Fun fact: if Lua did have multi-threading, I would probably not be developing #Kittyscript, or it would be a Lua precompiler)

@hyc@mastodon.social @mcc@mastodon.social I think it's somewhere between Lua and Lisp with a highly extensible compiler allowing opt-in static typing, high context linting and a lot more. At least that's what I'm trying to create with the #Kittyscript project, but between ADHD, depression and a day job to live off, there's very glacial development progress.

@argv_minus_one@mastodon.sdf.org If I may shill my future projects a little: I plan on starting a tech company, #Lunatronex, with a hardware division to be called Strawberry. Strawberry won't sell "smartphones", but there will be offered pocket computers with a cell modem that can do everything a smartphone can AND everything a PC can. They'll run KittyOS, the #Kittyscript based OS I want to write at some point. Getting root privileges on KittyOS will be as easy as flipping a checkbox in expert settings. No external hardware required, no pointless restrictions or wait times. KittyOS expert settings won't require a secret trick to enable like Android's developer settings with their "tap the build number seven times" thing. And the bootloader will be unlocked by default. No bullshit like "anti rollback" or anything like that. Install whatever OS you want with no pointless obstacles or bricking risks.

#Kittyscript's design is kinda between a (Scheme-y) Lisp and Lua tbh. The vararg and multiple return handling is very similar to Lua 5.5 (even before that version released). The method handlers kinda work like Lua's metatables except that they're functions instead of tables. They're also used for general method calls. The records (which user defined objects will be built upon) are very similar to Scheme. It has Lisp-style cons pairs. Kittyscript has dynamically typed semantics. There will be an optional static type system though. Kittyscript uses the same falsiness as Lua (null and false are false, everything else is true) It will have Lisp-style macros. The macros will be able to read and modify the context of the expression, and return any expression they want. The default textual syntax hasn't been decided yet, probably will be something similar to Javascript, Java, Kotlin or Lua. There'll also be a Lisp style parentheses syntax available. I might make a Lua mode for Kittyscript that parses Lua code and runs it through the Kittyscript compiler.

My current concept for the #Kittyscript compiler involves compile-time side effects. But because a later expression can change a previous expression and potentially remove it, it needs to have a way to roll back side effects too, at least the effects on the compilation output object. For example an expression defining a function must be able to delete the function if the expression gets removed. This could probably be handled with an optional cleanup callback, kinda like React's useEffect.

@hsza@social.tudbut.de @david_chisnall@infosec.exchange @tasket@infosec.exchange modular software design is already something I'm trying to do with the #Kittyscript programming language I'm developing, where the standard library is modularized.

Lisp-style macros could probably eliminate a lot of the "need" for LLMs and other, more deterministic forms of source code generation. #Kittyscript will have Lisp-style macros!

Today's #Kittyscript design thoughts topic: The structure of the compiler mid-end. My current concept is that there's a mutable compilation context object that's fed expressions that add expressions/statements to the current function, or install callbacks, while being able to read the context. The callbacks do things like reacting to a variable being defined syntactically after the point of reference, where the callback then sets the reference to the now defined variable. Lambdas or nested scopes create a new compilation context that partially reads/writes through to its parent context. Library and user plugins can add arbitrary additional behavior to compilation. RE: https://void.lgbt/objects/3c7abb8e-f7a4-4b2a-8aad-928bb5e3f49d

Today I spent way too much effort on trying to come up with semantics for the representation of #Kittyscript values as values of the target language. (Kittyscript will have the ability to compile to source of other languages) I decided it's an implementation detail of the compiler backend for the respective target, able to be influenced by annotations that can be ignored by incompatible backends.

@ifixcoinops@retro.social What do you think about the name of my programming language project Kittyscript? The name is cat themed and an originally unintended pun on script kiddie. #Kittyscript