Snippet Zone

Em3w parensordot

```
const vals = {
```
```
  E: 0, M: 90, '3': 180, W: 270
```
```
}
```
```
 
```
```
// const byDeg = {
```

//   0: 'E', 90: 'M', 180: '3', 270: 'W'

```
// }
```

const byDeg = Object.keys(vals).reduce((acc, key) => {

```
  acc[vals[key]] = key;
```
```
  return acc;
```
```
}, {});
```
```
 
```
```
 
```
```
const ops = {
```
```
  ')': 90, '(' : -90, '|': 180
```
```
}
```
```
 
```
```
function rotToSym(v) {
```
```
  if (v < 0) v += 360;
```
```
  const deg = Math.abs(v % 360);
```
```
  return byDeg[deg]
```
```
}
```
```
 
```
```
function op(char, op) {
```

  if (char === 'M' && op === '|') return 'M'

  if (char === 'W' && op === '|') return 'W'

```
  let v = vals[char]
```
```
  v += ops[op]
```
```
  return rotToSym(v)
```
```
}
```
```
 
```
```
 
```
```
function emw(prog) {
```
```
  prog = [...prog]
```
```
 
```
```
  let chars = []
```
```
  let res = []
```

  for (let i = 0; i < prog.length; i++) {

```
    let char = prog[i]
```
```
    if (vals[char] != null) {
```
```
      chars.push(char)
```
```
    } else if (ops[char]) {
```

      chars = chars.map(v => op(v, char))

    } else if (char === '.' && chars.length > 0) {

      const num = chars.map(v => vals[v])

```
        .reduce((a, b) => a + b, 0);
```
```
      chars = [rotToSym(num)]
```
```
    }
```
```
  }
```
```
  return chars.join``
```
```
}
```
```
 
```
```
function expr(prog) {
```
```
  const orig = prog;
```
```
  prog = prog.split(/\s/)
```

  return orig + ' = ' + prog.map(emw).join` `

```
}
```
```
 
```
```
document.body.appendChild(
```
```
  Object.assign(
```
```
    document.createElement`pre`, {
```
```
      innerHTML: 
```
```
`
```
```
Em3w parensordot 
```
```
 
```
```
// rotate 90 clockwise
```
```
${expr('EEE)')}
```
```
 
```
```
// rotate -90 clockwise
```
```
${expr('W(')}
```
```
${expr('W((')}
```
```
 
```
```
// mirror
```
```
${expr('E|')}
```
```
 
```
```
// mirror
```
```
${expr('EM|')}
```
```
 
```
```
${expr('WW3) MM) EEEM).')}
```
```
 
```
```
// sum rotations
```
```
${expr('MMM.')}
```
```
 
```
```
${expr(
```
```
`E) E( E)) EEE))) E)))) MM33).`)}
```
```
`}
```
```
  )
```
```
)
```

Fun thing I wanted to make for awhile… definitely going to do some doodles of this in my sketchbook…

Code description from GPT4 because I’m too lazy to write one…

This code is implementing a form of symbolic computation using a transformational language. This language has four primary symbols: “E”, “M”, “3”, and “W”. Each of these symbols is associated with a specific angle: 0, 90, 180, and 270 degrees, respectively.

There are also special symbols, which act as operators that perform certain transformations on the primary symbols:

“)”: Represents a rotation 90 degrees clockwise.

“(“: Represents a rotation 90 degrees counter-clockwise.

“|”: Represents a mirror operation, which reverses the direction. However, “M” and “W” are unaffected by this operation.

“.”: This operator sums up all previous primary symbols (by their respective degree values), resulting in a new symbol. The degree value of the new symbol is the sum of the previous degrees modulo 360.

The function emw(prog) interprets a string prog as a sequence of symbols and operations. It reads each character in the string and based on whether it’s a primary symbol, operator, or a “.”, it either adds the symbol to an array or performs an operation on the existing symbols in the array.

The expr(prog) function splits the input string prog into space-separated substrings. It interprets each substring as a sequence in the transformational language, using the emw function. It then joins the results together with a space and prepends the original input and an equals sign to give a string representation of the transformations.

The final section of the code generates a series of examples of expressions in this language, evaluates them using the expr function, and adds the results to the HTML body of a webpage in a formatted manner. This gives the user a way to see the transformations in action.

July 24, 2023

// humor // javascript // obfuscation // speed-coded // speedcoding // strings

Concatenative JavaScript

```
const vars = {}
```
```
 
```
```
const as = s => v => vars[s] = v
```
```
 
```
```
const def = s => v => {
```
```
  vars[s] = v
```
```
}
```
```
 
```
```
const set = (last, prop, val) => {
```
```
  last[prop] = val
```
```
}
```
```
 
```
```
const put = (last, prop, val) => {
```
```
  last[prop] = val
```
```
  return last
```
```
}
```
```
 
```
```
const of = k => run.last[k]
```
```
const $ = k => () => vars[k]
```
```
 
```
```
const run = (prog, log) => {
```
```
  run.stack = []
```
```
  let curr
```

  for (let i = 0; i < prog.length; i++) {

```
    let val = prog[i]
```
```
    if (val != null && val === $) { 
```
```
      run.stack.push(val())
```

    } else if (typeof val === 'function') {

```
      let ctx = null
```
```
      if (document.body[val.name]) { 
```
```
        ctx = document.body 
```
```
        val = val.bind(ctx)
```
```
      } else if (document[val.name]) { 
```
```
        ctx = document
```
```
        val = val.bind(ctx)
```
```
      } 
```
```
 
```
```
      if (log) console.log('exec', 
```

        val.name == 'bound ' ? '\u03BB' : val.name, run.stack)

```
 
```
```
      curr = val.apply(ctx, run.stack)
```
```
      if (curr != run.stack) { 
```

        run.stack = curr != null ? [curr] : []

```
        if (typeof curr === 'object') {
```
```
          run.last = curr
```
```
        }
```
```
      }
```
```
    } else {
```

      if (val != null) run.stack.push(val)

```
    }
```
```
  }
```
```
}
```
```
 
```
```
const showStack = () => {
```
```
  console.log('- stack:', run.stack)
```

  console.log('  -> last object', run.last)

```
  return run.stack
```
```
}
```
```
 
```
```
const _ = new Proxy({}, { 
```
```
  get: (o, key) => (() => (...a) => 
```
```
    run.last[key].apply(run.last, a)
```
```
  )()
```
```
})
```
```
 
```
```
// try it out
```
```
 
```
```
run( 
```
```
  [ 'div', 
```
```
    document.createElement, 
```
```
    document.body.appendChild, 
```
```
    as`myDiv`,
```

    'innerHTML', 'mini <b>concatenative</b>', set,

```
    'style', of, 'color', 'green', set,
```
```
 
```

    'just logging the element', $`myDiv`, console.log,

```
 
```
```
    'canvas', document.createElement, 
```
```
    document.body.appendChild, 
```
```
    'width', 500, put,
```
```
    'height', 500, put,
```
```
    def`myCanvas`,
```
```
 
```
```
    '2d',
```
```
    _.getContext,
```
```
    'fillStyle', 'red', set,
```
```
    100, 30, _.translate,
```
```
    0, 0, 10, 100, _.fillRect,
```
```
    20, 0, 10, 100, _.fillRect,
```
```
    .2, _.rotate,
```
```
    -30, 25, 100, 10, _.fillRect,
```
```
    -20, 55, 100, 10, _.fillRect,
```
```
 
```
```
    {}, 
```
```
    'name', 'zevan', put,
```
```
    'age', 82, put,
```
```
    JSON.stringify,
```
```
    as`person`,
```
```
 
```
```
    showStack
```
```
  ]
```
```
)
```
```
console.log(vars);
```

I recently spent some time reading about and playing with the FORTH language. I keep finding myself creating weird vaguely FORTH inspired snippets now… This one processes an array that’s in a concatenative format like this:


[ 'hello world', Date.now(), console.log ]

Arguments are collected on a stack and passed to a function when a function is hit in the array. There are some odd helper functions for setting properties, setting nested properties, running functions with a specific context etc…

Here is GPT4’s mostly correct explanation of what it does

This is a rather unusual piece of JavaScript code that creates a simple “programming language” based on the concept of a stack machine, and runs a “program” in this language. It resembles some sort of DSL (domain-specific language) or script-like construct.

Here are what the main components do:

vars: This is a dictionary that stores variables defined in the program.

as: This is a function that takes a string s and returns a function that takes a value v, storing v in vars under the key s.

def: Similar to as, it defines a variable in vars.

set: This function is used to set the property of an object. It takes the object last, the property name prop, and the value val, and assigns val to the property prop of the object last.

put: Similar to set, it sets the property of an object and returns the updated object.

of: This function gets the property with name k of the last object returned by the program.

$: This function is a getter for variables in vars.

run: This is the main function that runs the program. The program is an array of actions, where an action can be a function, an object with a name of ‘get’ (which pushes the result of calling the function onto the stack), or a value (which is pushed onto the stack).

showStack: This function logs the current state of the stack and the last object returned.

_: This creates a new Proxy object that allows arbitrary methods to be called on the last object returned by the program.

The run function is then called with a list of actions to perform. The actions include creating a div and canvas element, appending them to the body of the document, setting their properties, and drawing on the canvas. It also creates an object with a name and age, converts it to JSON, and stores it in a variable. Finally, it shows the state of the stack and logs all the variables.

July 23, 2023

// arrays // hacks // humor // javascript // meta // obfuscation // oldschool // proxies // speed-coded // speedcoding

Little Trading Program

```
let id = 0;
```
```
function person(startValue = 100) {
```
```
  const props = {
```
```
    id: id++, 
```
```
    el: document.body.appendChild(
```
```
      Object.assign(
```
```
        document.createElement`b`, { 
```
```
          innerText: startValue,
```
```
          style: 'padding: 1em'
```
```
      })
```
```
    ),
```
```
    value: startValue,
```
```
    trade(other) {
```
```
      if (props.value <= 0) return;
```
```
      other.value += 1;
```
```
      props.value -= 1;
```
```
      other.el.innerText = other.value
```
```
      props.el.innerText = props.value
```
```
    }
```
```
  }
```
```
  return props
```
```
}
```
```
 
```
```
 
```
```
const NUM = 4
```

const people = Array.from({ length: NUM }, person)

```
 
```
```
setInterval(() => {
```

  const a = people[~~(Math.random() * people.length)]

  const b = people[~~(Math.random() * people.length)]

```
 
```
```
  if (a.id != b.id) a.trade(b)
```
```
}, 1)
```

4 “people” randomly trade…

I asked Chat GPT to describe this… funny response…

The trading program you provided is essentially an example of a random walk or “drunkard’s walk” problem. In such problems, each individual (in this case, the ‘people’) make random moves (in this case, trades), and we observe the resulting dynamics of the system as a whole. In this particular case, each trade involves one individual giving one unit of value to another individual. Since each trade is random, there’s a possibility that over time, all the value might get concentrated in one individual. This isn’t guaranteed, but given enough time, it’s likely. You could compare it to the idea that given enough time, a group of monkeys randomly typing on a keyboard would eventually type out the complete works of Shakespeare. It’s also worth noting that this concentration of value becomes more likely because the individuals with no value left cannot trade anymore, so they are essentially removed from the trading pool. This progressively reduces the number of individuals that can gain value and increases the probability of the remaining individuals gaining more value. This is a simple model of economic transactions and it illustrates how wealth can concentrate over time even if all the transactions are fair and random. Of course, it’s a very simplified model, and real-world economics are much more complex.

July 18, 2023

// arrays // humor // javascript // math // speed-coded // speedcoding

Other Gates from NAND

```
const nand = ([a, b]) => +!(a & b)
```
```
 
```
```
const not = ([a]) => nand([a, a])
```
```
 
```

const and = ([a, b]) => nand([nand([a, b]), nand([a, b])])

```
 
```

const or = ([a, b]) => nand([nand([a, a]), nand([b, b])])

```
 
```
```
const nor = ([a, b]) => 
```
```
  nand([ 
```

    nand([nand([a, a]), nand([b, b])]),

```
    nand([nand([a, a]), nand([b, b])])
```
```
  ])
```
```
 
```
```
const xor = ([a, b]) =>
```
```
  nand([
```
```
    nand([a, nand([a, b])]),
```
```
    nand([b, nand([a, b])])
```
```
  ])
```
```
 
```
```
const xnor = ([a, b]) => 
```
```
  nand([ 
```
```
    nand([nand([a, a]), nand([b, b])]),
```
```
    nand([a, b])
```
```
  ])
```
```
 
```
```
 
```
```
const inputs = [
```
```
  [0, 0],
```
```
  [0, 1],
```
```
  [1, 0],
```
```
  [1, 1]
```
```
]
```
```
 
```

const testGate = ({ gate, truth, result }) => console.log(

```
  gate + ' matches truth? ', 
```
```
  truth+'' === result+'' ? 
```

    'yes :D' : `nope :( ${truth} ${result}`

```
)
```
```
 
```
```
testGate({
```
```
  gate: 'NAND',
```
```
  truth: [1, 1, 1, 0],
```
```
  result: inputs.map(nand)
```
```
})
```
```
 
```
```
testGate({
```
```
  gate: 'NOT',
```
```
  truth: [0, 1],
```
```
  result: [[1], [0]].map(not)
```
```
})
```
```
 
```
```
testGate({
```
```
  gate: 'AND',
```
```
  truth: [0, 0, 0, 1],
```
```
  result: inputs.map(and)
```
```
})
```
```
 
```
```
testGate({
```
```
  gate: 'OR',
```
```
  truth: [0, 1, 1, 1],
```
```
  result: inputs.map(or)
```
```
})
```
```
 
```
```
testGate({
```
```
  gate: 'NOR',
```
```
  truth: [1, 0, 0, 0],
```
```
  result: inputs.map(nor)
```
```
})
```
```
 
```
```
testGate({
```
```
  gate: 'XOR',
```
```
  truth: [0, 1, 1, 0],
```
```
  result: inputs.map(xor)
```
```
})
```
```
 
```
```
testGate({
```
```
  gate: 'XNOR',
```
```
  truth: [1, 0, 0, 1],
```
```
  result: inputs.map(xnor)
```
```
})
```

Use NAND to create a bunch of other gates 😀 – I used this wikipedia article for reference

July 16, 2023

// arrays // golfed // humor // javascript // math

Multiplicative Persistence

```
const multp = (val, count = 1, res) => 
```
```
  (res = (val + '').split``
```

    .reduce((a, b) => a * b, 1) + '').length > 1 ?

```
      multp(res, count + 1) : count
```
```
 
```
```
 
```
```
console.log('test:', multp(2678789))
```

Started watching this youtube video from numberphile and instantly made this half-golfed thing

Found this:

f=n=>[n,...n>9?f(eval([...n+''].join`*`)):[]]

By Arnauld over at codegolf.stackexchange

will definitely remember: [...n+'']

June 10, 2023

// golfed // hacks // humor // javascript // math

Older Posts

Em3w parensordot

Code description from GPT4 because I’m too lazy to write one…

Concatenative JavaScript

Here is GPT4’s mostly correct explanation of what it does

Little Trading Program

Other Gates from NAND

Multiplicative Persistence

Recent

Archive