A village pops up. There is no point to it. You can click to make more houses. You can right-click to drag things around. When I touch it again I think I'll add a sun and moon that track the time of day for wherever the user is located. Actually the footer has art too, each page has a semi-randomly assigned illustration from public-domain (old) art that I've found. Like drawings from James McNeill Whistler, for instance. I use his illustrations in 'useful' websites too.
Actually, I experimented with the sun/moon a few years ago, in this version: https://simonsarris.github.io/simeville/
If you left-click drag the sun downwards, you'll see the moon come up. That one is open source, but the code is quite slapdash compared to the new one. Also you have to click ITS TIME TO BUILD to get the buildings.
In general I think websites could be a lot more pretty (gorgeous even), silly, interesting, and a lot less corporate chic than they currently are.
Currently I just have an animated GIF background, but I've had some animated ASCII art in the past.
I'm currently working on animating a fractal drawn with HTML Canvas.
Your houses and pencil style are very cute, I feel inspired to make something similar.
I'd like if clicking in the same place would grow whatever's there.
I wrote a flame simulation in x86 assembly language. Total hoot.
I also wrote an Easter egg that shipped in a major software company’s software and is immortally burned onto thousands of DVDs slowly rotting in landfills. This one was fun and challenging because I had to mask the names of the product team from easy detection, I had to convert string text to my own custom 8x3 pixel font for rendering, I played with palette animation to create some fun raining effects, and I packed it into just a few Kb of the DOS end of a Windows executable (back in the day, 16-bit Windows apps could be linked with a custom DOS loader in case you tried to run the Windows app from the cmd line).
IOCCC gang rise up. This is mine: https://www.ioccc.org/years.html#2005_persano
Turns out, this is actually a real challenging task for computers - what the eyes perceive as dominant, computers do not and vice-versa. For example, if you draw a small circle on a black board with white chalk, take a picture of it and ask a computer, it will tell you black is the dominant color because it covers most of the pixels. Whereas, any human would tell you the white drawing is the dominant color because it stands out.
There are some ways of guiding the computer to get the color palette you want out of an image, but they are never as accurate. Over the years, I would from time to time, throw a bunch of images at it - ranging from portraits to beautiful flowers from gardens to see how my algorithm would perform and improved it bit by bit. I would say, it is close to 90% accuracy now and I still work on it over the weekends. It has no use cases so far (for me). It just exists as a pure passion project that got me excited about programming such algorithms.
Recently, I did a Fashion degree just out of passion and I realized this code has so much applications for things like making mood boards and color palettes from inspiration boards. However, none of my professors nor fellow students were impressed or saw utility in it because they believed no algorithm can match or replace a true creative process. They are pretty old-school about this, so, there's that. But, they just didn't seem to understand the technical challenge about this seemingly simple task.
However, over the years, I did build an API around this algorithm, kept fine tuning it and even made some marketing material for it. For no purpose other than reminding myself of why I am excited about programming.
If you're interested, here is a decade old snapshot of the algorithm's output:
It's a live pixel mosaic where anyone can change the color, with the color being chosen randomly, so the chances of two adjacent tiles having the same color are quite low. I also log the country to see where people who have clicked it are from.
I am currently working on a desktop 8x8 LED grid to sync the same pattern on my desk.
Teco was something the CS upper classmen were using to prove their hacker creds back at Rose-Hulman in 1981. It's a horrible editor, but it does macros, and was good enough to build the first version of EMACS.
It gave me the chance to play with some old unix concepts in an nspawn container.
https://github.com/brightbox/systemd-dining
As well as incorporating the Philosopher’s Song and some profound statements into the journal.
https://github.com/incanus/subleq
It was fun to see how simple a model of computation could actually be.
A concrete example is Nikki, a demo released in 96 and captured (with some technical difficulties) by a friend here https://youtu.be/t8o-uuq73UU?si=4dlTla0s2mDCVzCK
Working on anything “useless” is profoundly life changing and “useful” on the long run!
Only now am I able to do more similar stuff (my current research is around music + code + lightning and videos, this time connected to real life performances), and it is massively pleasurable (and also likely one of the most technical types of work I will be working on for now!)
[1] https://codegolf.stackexchange.com/questions/176966/golf-a-n...
I would like to learn how GAN are working, then I scraped the official pictures of Italian politicians since 30 years and try to generate new faces with a GAN trained to this dataset. Unfortunately I need a lot of computing power to obtain an acceptable face, and I did not want to spend money for that.
Several years ago I wrote a Tinder bot to collect spam messages and malicious links. I stopped early because I got messages from several of people that I know personally in a relationship or even married
I wrote code that automatically calculated the previous working date - including those floating dates around Easter.
I generated calendars for future years to compare to know calendars to prove no discrepancies.
My code worked. My management did not understand how it worked or how it could work.
We continued using manual input.
I've written some: a programming language interpreter based on Abadi and Cardelli's untyped ς-calculus; a two-kilobyte web server in assembly (which accidentally did turn out to be useful); a self-compiling compiler from a sort of Forth dialect to i386 ELF executables; a translator from standard English orthography to an ASCII alphanumeric phonetic orthography I designed; a one-kilobyte programming language interpreter with dynamic multimethod dispatch and pattern-matching; a base-3 calendar based on the Sierpinski triangle; a C interpreter in Python I used for bytebeat livecoding; several implementations of Tetris, one of which is a 2K ARM executable; an operating system for ARM consisting of five instructions; a few raytracers; a Space Invaders game; a minimal roguelike in Forth; a library for manipulating Boolean functions as Zhegalkin polynomials; many symbolic differentiators; a sort of polyrhythmic drum machine called Pygmusic; a parametric CAD system in PostScript for laser-cutting MDF; 3-D rotating objects in ASCII art in 20 lines of Python; Karplus-Strong string synthesis in one line of C; an audio PLL in one line of C; an RPN calculator with forward-mode automatic differentiation; a slide rule in Tcl/Tk; a port of the logic-programming EDSL μKanren to OCaml; several fractal renderers; a decoder for the "gridfonts" Hofstadter and his research group designed; a Hershey font decoder; several maze generators; a generator for balanced-nonary multiplication tables; a vocoder; a Doom-like first-person raycaster; a teapot mod for the Minetest game; a compiler for a subset of Scheme written in itself; etc.
A lot of this is in http://canonical.org/~kragen/sw/dev3/ which you can clone with Git. I'd be happy to elaborate on any of these if you are interested.
I hate when I'm having fun and accidentally make something useful :)
So I wrote a matlab program to draw the shapes, and cut them out, and it works
It’s mathematically exact, not just approximate
Still surprises me after 20 years, so I want to find this old program again lol
Now I am more curious to find this program
Either I didn't do it optimally, or there is some variation like a triangle/rectangle/square
I think there are some problems that have 3 shapes, or it could be triangle/pentagon or something
Communicating via paste would work but speaking or typing was near impossible.
Back somewhere in the 1990s, I made a simple scrolling demo of a "platformer game level" in HyperCard. I didn't even bother designing a level or implementing any game mechanics - I just filled the level with random "tiles". The interesting part is that the tiles actually came from a custom bitmap font that I created with ResEdit (https://en.wikipedia.org/wiki/ResEdit) and manually added to the resource fork of the HyperCard stack. See, filling a text field and scrolling the entire field was the only way I found to get acceptable performance on 1st-gen Macs - certainly it was impossible by using a grid of button icons (even with screen locking), for example. The trick stopped working in System 7 and I never found out why but I was sad about it. I still have a text file that I've migrated from computer to computer, from 1999, with some notes about a purported way to display oversized "icons" on buttons using a PICT resource. I don't recall ever trying it.
In 2002, I developed some tools for working with DDR step chart edits, in Perl. Some online friends had hardware that allowed for transferring data between a computer and an PS2(?) memory card (which could also be used in an arcade cabinet), which they'd been using to share their edits; they were also involved in... some kind of precursor to Stepmania, which was using its own MML-like (https://en.wikipedia.org/wiki/Music_Macro_Language) format for step charts. I made a converter from that format to the "official" one, and an SVG renderer. I was also working on something that would attempt to give charts an "objective" difficulty rating programmatically, but I think I got too far lost in deciding the heuristics it should use. (I did have a working model of how the player's feet would be positioned while playing through the chart.)
In 2005, I implemented a "choose your own adventure" book engine - twice: in C++ and Python, for comparison purposes. The input was just an alternating sequence of blocks of prose for a "page" and directives for options the user could choose; the engine would parse this, present a menu after each page of book text, and go to the next page as appropriate. An empty menu section denoted the end of the story.
In 2007, I wrote a Python script that opens and parses an indexed PNG file at the byte level (no libraries), and modifies the palette (the version I found appears to just increase brightness a bit, but I remember having a version that applied a sort of pastel effect using varying amounts of desaturation and gamma correction).
In 2010, I implemented a non-recursive Towers of Hanoi solution.
In 2014, on Stack Overflow (https://stackoverflow.com/questions/21297887/), I did a simple radix sort implementation in Python specifically for Burrows-Wheeler transforms - rather than actually creating the rotated byte-string inputs, it just sorts according to the hypothetical rotated versions (i.e., according to the element value at certain indices, modulo the length of the elements). That wouldn't be particularly noteworthy or practical (it's just not a problem you'd expect people to ask about on Stack Overflow very often - although I did just now find one unclosed duplicate from 2018 and cleaned it up ;) - and would probably have been better asked on softwareengineering.stackexchange.com), but it did happen to get the attention of a certain Tim Peters.
In 2016, I did a bunch of work on optimized text compression for retro video games. My target corpus was about 1MB of text, but split into thousands of short strings (varying from a few bytes to a few kilobytes) - and the game needs to be able to extract arbitrary strings on demand, individually and efficiently. I developed a system that would develop a rather complex tokenization scheme (with tokens varying from a short prefix or suffix, to several words in length) based on a variety of heuristics, then store the tokens as an optimized overlapping string pool and use a custom optimized Huffman tree representation to index the pool. Oh, and the pool itself is also Huffman-compressed again, this time with simple one-byte symbols.
In 2022, I had the shower thought that any divide-and-conquer algorithm can be reimagined as a graph traversal problem, where the function calls are nodes in the graph; and I made... this thing: https://github.com/zahlman/larch. If you can figure out how to do anything useful with it, congrats; I don't remember, myself.