I think fundamentally the design of the language would be oriented around having this simulated catgirl be the abstract machine of the language, such that we can imagine her performing the calculations for us :3
big big expressions could be confusing for her… hmmm… perhaps there's a limit to their 'complexity' (according to some metric) before she gives up parsing them. maybe the language syntax is somewhere between stack based and expression oriented so you can break it up for her. or something
also she's 100% a silly puppy and we need a ball throwing analogy somewhere in the language. and treats. and leash. and all the things
probably not object oriented, probably would make you forget theres a puppygirl in your computer, the language needs to enforce that all abstractions gotta be puppy oriented… somehow :P puppy oriented programming…POP? I feel like someone could come up with a better acronym than that :3
concurrency would be painful as you must somehow work with the scheduler such that she's not overwhelmed or confused by the order in which she performs computations. idk how "confusion" is measured, dont ask
maybe we just try and reduce the frequency of thread context switching to make things easy for her for now :3ok maybe the ball throwing analogy is like making context switching an explicit part of the language and you "throw" a ball to another thread to switch to it?? probably would be too confusing… I shouldn't spend this much time thinking about concurrency for this anyways lmao
maybe you get to control how much adhd this catgirl has making all computational constructs "fuzzy" by implementing this paper: https://arxiv.org/abs/1605.06640
the more adhd, the more uncertainty in the abstract machine state
Programming with a Differentiable Forth Interpreter
Given that in practice training data is scarce for all but a small set of problems, a core question is how to incorporate prior knowledge into a model. In this paper, we consider the case of prior procedural knowledge for neural networks, such as knowing how a program should traverse a sequence, but not what local actions should be performed at each step. To this end, we present an end-to-end differentiable interpreter for the programming language Forth which enables programmers to write program sketches with slots that can be filled with behaviour trained from program input-output data. We can optimise this behaviour directly through gradient descent techniques on user-specified objectives, and also integrate the program into any larger neural computation graph. We show empirically that our interpreter is able to effectively leverage different levels of prior program structure and learn complex behaviours such as sequence sorting and addition. When connected to outputs of an LSTM and trained jointly, our interpreter achieves state-of-the-art accuracy for end-to-end reasoning about quantities expressed in natural language stories.
