I credit this site for really kickstarting my career in software development from a somewhat early age. Big shout out and thank you to Lode. Back then, I practically memorized all the pages and examples in https://lodev.org/cgtutor/, even if some of the math went right over my head at the time

Edit: Just looked through some old files and found the program. It was written in fasm in 2019 and generates an XPM2 file (which I had to manually convert to XPM3 to view). Here's the resulting image: https://i.postimg.cc/FsFhXSHG/xortiles.png

(I can post the code if anyone wants, though I don't know why you'd care.)

(I think, maybe?)

(Ducking while posting my own blog: https://nicknash.me/2012/10/26/happy-halloween/)

  5 4 7 6 1 0 3 2

It was originally written for the PDP-1 in the early sixties. I’ve seen it demonstrated on the Computer History Museum’s PDP-1. I always wondered how the characteristic “XOR texture” could be produced if the PDP-1’s display can only plot points and does not use a bitmapped framebuffer.

Turns out it takes advantage of the long persistence of the screen’s phosphor, and the brightness of each point decreases over time.

The CHM has a video of it running online, but it does not capture the effect of the phosphor persistence: https://www.computerhistory.org/collections/catalog/10266415...

Edit: here’s a video of it running in MAME that somewhat shows how phosphor persistence creates the XOR texture: https://youtu.be/AxJzUiaQ7xM?si=X9K47c4WyD6AisUp

https://www.dwitter.net/

Dwitter is like Twitter, but for one-line javascript examples using canvas. Users are limited to 140 bytes in their creations.

And here are several variations using other binary operators to create the Sierpinski triangle: https://www.dwitter.net/h/sierpinski

Even though it is 20 years old, a lot of that stuff can still find a use somewhere, especially if you do shader work.

  ~:"1/~&.#:i.2^8

Their website is pure gold. Also, I love the layout even more today.

I would like to build a site geared towards this kind of algorithmic art. Where one can paste the JS code snippets and see the resulting image. Similar to my html editor with instant preview:

https://github.com/no-gravity/html_editor

But with the ability to link to the code.

Is it feasible these days to build something like this, but without the ability of the code to jump out of the result frame? Like no external http requests, no fiddling with the window etc?

If you needed tighter sandboxing than that, then I think WebAssembly is your best bet because you can control exactly what APIs are exposed to a WebAssembly module. You could then let users submit WebAssembly modules or let them submit JS that will be run in a JS interpreter running in WebAssembly. I think https://github.com/justjake/quickjs-emscripten or https://github.com/fermyon/StarlingMonkey (used by https://github.com/bytecodealliance/ComponentizeJS) look good for that.

    <iframe sandbox="allow-scripts"></iframe>

    <script>
        document.querySelector('iframe').srcdoc=`
            <meta http-equiv="Content-Security-Policy" content="default-src 'none'; script-src 'unsafe-inline'">
            <span>Hello</span>
            <script>
                document.querySelector('span').innerHTML+=" world"; 
                fetch('/');
            </sc`+`ript>
            <img src='https://placecats.com/300/200'>
        `;
    </script>

However there are certain things that it still doesn't protect against: CPU and memory exhaustion. Someone's script can hog those resources and possibly cause the browser to crash the tab. If you only execute one user's code at a time when a user of the site specifically browses to it / activates it, then it might be acceptable because a user can learn to not re-activate code that just crashed their tab and won't be missing out on anything else, but if you had a setup where it didn't take user action to run other users' code (like you have a homepage that automatically shows a running preview of other people's code, or you have a multiplayer programming game where each player submits code and everyone in the game sees it run together and interact with other players' code) then it could be purposefully griefed by players submitting code that exhausts resources. If you need to protect against local denial of service attacks like this, or if you needed strict determinism for some reason, then I think a WASM-based solution is still the way to go.

Really cool!

it's my go-to for lining up pixel-perfect uv maps for more geometric/mechanical 3d assets -- the recursive nature means you can have an easy time hitting, say, the exact corners or centers of luxels if you feel the need.

    pixels[x][y] := (x OP y) BITWISE_AND mask

However, according to these replies here the XOR texture and the Sierpinski triangle/tetrahedron are indeed mathematically related: https://math.stackexchange.com/questions/1080223/what-do-bit... (Admittedly I don't understand the mathematics behind this connection)

  import numpy as np
  import matplotlib.pyplot as plt
  n = 2048
  X, Y = np.mgrid[:n,:n]
  plt.imshow(X^Y, cmap=plt.cm.Spectral)
  plt.show()

> However, it's not suitable for applications such as art or games.

uhhh why not suitable for art? I'm digging into it right now and made some trippy stuff!

https://xor-pattern.netlify.app/

The way the patterns looked, felt natural enough that my brain was trying to make sense of the chaos.

PLEASE, for the love of god, send it to me later. I am extremely interested (not just saying that). tomomyrman@proton.me or reply here

or, let's collab!

Using it as-is tends to be discouraged though, because it is considered unoriginal and lazy for all but the tiniest of intros. Variations on it are fine.

I guess because it's been seen before? Don't let anyone else yuck your yum though - if you like it and find a way to make it look cool, use it!

    color = ((x ^ y) & 1) ? black : white;

https://www.shadertoy.com/view/wstBz4

They're set by screen, exactly!

1. The ability for the code to process the error and recover from it 2. The ability to sensibly log, trace, and later for a human to understand the error after the fact

The later of these is best handled by using a tracing library systematically throughout your code to spit out open telemetr and “logging” the error within your local span. You can then debug the problem with a tool like honeycomb which’ll give you a much clearer idea of what’s going on. Having tracing in place will also help you debug in cases where you don’t have errors but your system is running slowly, doing something unexpected, etc.

This greatly reduces the problem domain you have to solve in actual error handling to just having the computer recover when something is recoverable. And in these situations it turns out that most recoverable errors are best expressed as “non-errors” once they migrate any distance from the origin of the error (e.g. the record not found turns into a standard “user not known” status return value - it’s no longer an error, but an expected behavior of the system!) So for these “short lived” errors that are either handled locally or bubbled up all the way to the top and never handled, I’ve found that Go’s native basic error framework is fine.