IDEAS

Q[DQ\2023

---

time travelling languages

languages where control flow is not linear or sequential

languages where values remember their previous values, or the operations that
  happened to them or that they participated in (in other words, computation
  histories are first class objects)

lossy self-compressing languages that compile to approximations (maybe with the
  benefit of interpolation or extrapolation, or maybe the benefit is simply size
  or speed)

optimizing compilers that use optimizations that are usually true but not quite
  true or not always true (but unlock really aggressive optimization)

quantumy languages where side effects happen because of entanglement between
  components

physically-based languages (as in “based on physics”) (see LittleBigPlanet)
  where your code is in a physics simulator (for example, if pointers are
  wiggled around too much, their values change a bit)

languages where there’s a high probability that cat’ing /dev/random to a file
  (and mapping it to ASCII by clearing the top bit) is a valid program

languages with interactive compilation

languages where every operation is reversible

languages with Monte Carlo computations

random languages where no operation is totally deterministic

languages with pessimizing compilers (but that still guarantee forward progress)
  (perhaps trying to guarantee program execution be bounded by a fixed amount of
  memory, or the compilers don’t emit any code that is entirely useless)

“garbage-in, garbage-out” languages

languages that track time complexity

machine-learning everything (where the programmer specifies input-output
  pairs for functions and the compiler trains a model and emits that)

functions with colors as a feature

optimizing for everyday computing

  compilers that emit multiple implementations or versions of a function
    (and you get to pick afterward, or the compiler picks based on tests)

  shell languages that saves the intermediate results at each pipe (since we
    have lots of memory, and disk space is limitless!)

golfing compilers that don’t optimize for speed but for space, or that enforce
  some limit on the number of syntactic elements in a function (for example,
  the programmer gets one loop or if-statement)

languages where a while-loop really is “while” (that is, it’s reëvaluated
  in-between every statement)

languages that uses all the same keywords and syntactic elements as usual
  programming languages but where those mean something completely different
  (but are still reasonable in a layman’s interpretation)

languages where parallelism is indicated by writing code side-by-side in columns
  (or perhaps something like VLIW in software)