- Frontend JS minimalism. Any stories about people ditching transpilers, build tools etc appeals to me immensely. My spicy take is that React is not an abstraction above the DOM, it's an abstraction parallel to it.

- Concatenative langauges. Less Forth and more Joy[0]. I just feel like there's something here, and the idea will not die until it catches on. The amount of concatenative language interpreters I've abandoned is a bit embarassing.

[0] https://hypercubed.github.io/joy/joy.html

Earlier this week, I watched an excellent talk by Devine Lu Linvega where he was doing a bunch of digging into minimal programming languages. He spent a lot of time looking into Forth and other concatenative languages and he said he found a lot of implementations of the languages, but very little code written in them. It was as if soon as the implementers actually tried to use the thing they created, they gave up.

So your experience isn't unique. I've also written a couple of concatenative languages and quickly abandoned them after trying to write more than toy programs and realizing I wasn't smart enough to reason about the stack in my head.

Looks like my last attempt failed when I got bogged down prototyping a type system in Ocaml then trying to port that to Zig.

So in my case - it's not because I use them and they suck, it's because I find stuff like implementing type systems and GC very hard, and usually more practical things start wanting my attention more.

I believe that adding types and data structures to Forth, as is done in STOIC, combined with an IDE that allows you to SEE what parameters get eaten where, could make Forth viable for larger programs.

I tried to do this with MSTOICAL, which you all helped me to get to compile... but then I couldn't disentangle it from the build system, and my retina blew out... causing me to lose the ability to focus on the project.

  "a Turing machine is also equivalent to a two-stack PDA with standard LIFO semantics, by using one stack to model the tape left of the head and the other stack for the tape to the right."

Do you have a source of this video?

This talk will be published in a few days, fully-annotated at the Conference Guide [0] where you can download presentations for free. Sign up for the newsletter [1] to stay up-to-date (we're indie and the extra eyeballs help.)

Anyhow, the other comments linked the raw streams already :)

[0] https://guide.handmade-seattle.com

[1] https://handmade-seattle.com/newsletter

Handmade Seattle 2022, Day One. Around ~1h25min in. I assume this is the video.

A lot of the time it seems like you really don't need advanced conflict resolution, if you change your actual UI model to be inherently parallel, which you often can.

A collaborative document editor is hard. A forum that lets you post offline is easy. At worst a conflict will get a few out of order posts, which is not an issue if people use @references, reddit style trees of comments, or there's low enough volume that it's unlikely to be confusing. Post race conditions already exist in forums anyway.

There's a lot of low hanging fruit in P2P and offline first, and everyone seems to be mostly doing the hard stuff like cryptocurrency instead.

Ooooo, got links?

Out of curiosity, how heavyweight is Syncthing, computationally? Could it run in an ESP32? I've used that same "folder that syncs" concept in some of my own designs which I would love to push down to smaller hardware...

I haven't looked into the internals of ST all that deeply, partly because IIRC it's written in Go(Like so many P2P apps) and I'm not familiar with it.

From what I know of it, you could probably port it, just because the ESP32 is really powerful, but it would be a big rewrite. IIRC ST uses some kind of embedded database, not SQLite but similar-ish, I think it might be NoSQL.

I looked into it at one point because I wanted to add some features, but abandoned that when I found out how committed the devs are to sticking to the core functionality only.

I think if I were going to push it to ESP32(Which seems like an amazing idea) I might look into a custom embedded-first protocol.

It would be amazing if SyncThing could add support for a lite version of the protocol, but I doubt they would. The community seems to not mind forks though, maybe someone can make a "SyncThing for IoT" fork?

I've been obsessed with machine learning for embedded systems for years! So many practices around ML assume constant network connection and/or that your service runs in a data-center. I'm an ex-SRE and love building reliable offline computer vision things!

Presumably not online

Nowhere. Should we start something? :)

I feel like a lot of ham radio networking is still "offline" from an internet perspective; you may have a LAN or even a WAN but no connection to root DNS or certificate servers or whatever. This tickles my fancy: https://blog.thelifeofkenneth.com/2018/01/off-grid-raspbian-...

I feel like /r/darknetplan is tangentially related, but not quite what I'm looking for.

I've been playing with Internet-in-a-box, which is precisely wrong about its name; it's an offline repository of content that was developed on the internet.

Someday I'd like to marry that with my Othernet receiver, which is a similar offline-hotspot-of-content but keeps that content updated by receiving a satellite data stream. (One-way only.)

Piratebox seems to be a dead project by that name, but I like the idea. A local file repo and possibly bulletin-board for use by folks within range of the box.

Yes, yes, yes, where do we go to chat?

I'm open to wherever people naturally gather though. IRC, maybe?

Another community you might like: https://www.tinyml.org/

Half the skill in the art of programming is choosing good names, but Joy lacks names for arguments and locals.

Otherwise, it looks interesting. But, I think I’ll stick to lisp.

Why do you think this? Would be interested to hear the reasoning behind the take.

Great, we already have a library for that - it's called the DOM.

Don't get me wrong, I'm all for reactive programming, and even templated views. But reacts approach of hiding everything under the rug rather than having a clear "here's where the state changes" and "Here's we we render" divide always struck me as the worst of both worlds.

Been going down this path recently via Svelte & SvelteKit: It's been really fun seeing the network responses of the first load being full HTML for any page (SSR), with JS responses handling transitions in between pages (CSR).

I've even managed to get my SVG image generator to run server-side first before passing over, with any changes handled client-side & with URL changes. Refreshing with the changed parameters renders the newer SVG. :)

I was mainly involved in the logistics side of things - moving & tracing livestock, fruit. Long and the short of it most people, solutions and systems just assume always-on internet, which as you can imagine in remote regions is not a reality (even if it's a reality within range of the farmhouse router with starlink, the front gate could be miles away).

Half way through their demo, there was a power outage at the farm (as happens from time to time). As it turns out, their [insert product] relied on a connection to either AWS or Azure for some key functionality. Power goes out, turns out they had been using the farm internet for that connectivity (LTE service was miserable in the region), so their huge machine just stops and sits there idling in the field. Can’t even command it to return back to the crowd. Meanwhile our drone is still running back and forth on our field area and we didn’t even notice that anything went wrong.

- https://zak.stunts.hu

- https://wiki.stunts.hu/wiki/Custom_cars

- https://forum.stunts.hu/index.php?board=90.0&label=stunts-re...

- https://www.rockpapershotgun.com/the-remarkable-community-ar...

Because both Stunts and "Zak McKraken and the Alien Mindbenders" were my favourite games as a kid, and they're pretty much unknown to this day. The Mars face, the aliens with the long head at the telco, the kazoo, all etched deeply in my memory.

I love the fact that there is someone that has played and loved the two same niche DOS games as myself :)

But indeed, that's Zak from the game! The favicon for the website is also a tiny version of the character's sprite.

Much thanks for letting us know.

Oh the memories!

I almost fell out of my chair when I found out there were no books on how to build them, so I wrote one: https://www.buildingbrowserextensions.com/ It was incredibly enjoyable to go through the APIs and write about all the different crazy things they can do, and I put the best ones into a demo extension: https://chrome.google.com/webstore/detail/browser-extension-....

Since then, I've on occasion had interest in making some other browser extensions, but I always look back to that experience & the lack of resources and just think ehhhhhh do I really want to? I'm sure I could but just how much do I care about this, and the answer has never been enough.

If you're looking to get back on the horse, check out Plasmo https://www.plasmo.com/. It's by far the best and easiest platform for building and deploying extensions.

To the best of the updates to my knowledge, they are much less powerful now than when we could use XUL many years ago...

I am not aware that the lackings forced around the time of the deprecation of XUL got fixed.

I still use browser forks to keep on using those vital extensions of yore (Scrapbook etc).

I want to build an ad-blocker.

Could you recommend a good open source projects to learn from?

Previous extension I made: www.fuckoff.yt

For a generalized ad blocker, importing and updating filter lists is probably the most challenging bit. https://kb.adguard.com/en/general/adguard-ad-filters AdGuard has an amazing blog, their content is impressively broad and deep https://adguard.com/en/blog/how-ad-blocking-is-done.html

HTTPS://headlamptest.com

Service workers are particularly problematic for some extensions, as the background script cannot execute indefinitely. I included an entire chapter on mv2->mv3 since there was so much to cover.

The warez scene in 90s and early 00s was fun to follow. I consider the NFO files a legitimate form of art, not to mention the skills for unpacking and keygen-ing or cracking of the protected software.

https://scenelist.org/

I am.

As a teenage boy, I had them printed with my father's dot matrix printer, and put them on my wall as decoration. Fascinating stuff.

https://www.youtube.com/watch?v=ZR454sxi27o

My friend was way further (better?) at the scene then I ever was but we'd pool our resources. I.e. he'd get access to an FTP and share it with me. I'd download disks 1 - 10 and he'd grab 11 - 20. We'd then use a direct dial program with our modems to share the remaining disks with each other (using ZModem!) overnight. Double our bandwidth!

I still install DAMN NFO Viewer on my main PC just so I can appreciate some of the .nfo files I still have.

    "files.associations": {
      "*.msg": "plaintext",
      "*.ans": "plaintext",
      "*.asc": "plaintext",
      "*.rip": "plaintext",
      "*.nfo": "plaintext",
      ...
    },
    ...
    "[plaintext]": {
      "files.encoding": "cp437",
      "files.eol": "\r\n",
      "editor.renderControlCharacters": true
    },

https://en.wikipedia.org/wiki/International_Network_of_Crack...

As a poor 12 year old they weren’t losing money. I had none!

[] https://github.com/acids-ircam/RAVE/tree/master/rave

1- A lot of options to influence/edit the generated output. What AUTOMATIC1111 is building for Stable Diffusion is the right direction (open extensions and manoeuvrability). I hope harmonai will get the same treatment.

2- Smaller minimum training requirements and simple retraining workflows. AudioLM is outstanding in this regard (but fails the first point)

3- Prod-level quality for end-user tools : Style/tone transfer and cloning plugins like DDSP-VST, mawf and yours (RAVE) sounds at best like DALLE-1 level quality. do you think we could make a DALLE-2 kind of jump soon?

And we do indeed lack public gathering places for this scene ! (or do we ?)

Here is a personal list I made of some AI Music creation tools: https://rentry.co/Music-Creation-AI-Tools

Merci IRCAM !

- Sites that work without JavaScript. Even better than the first, it's always a pleasure to see when a site is made properly for a change, without the toxicity of JavaScript that pervades the world wide web (WWW) as we know it.

Not sure about niche. Maybe more... understated, proprietary and confidential.

We've been doing totally vanilla HTML/JS/CSS web apps for our B2B customers for the last 3-4 years. In fact, we can't use your typical web frameworks because our contracts are measured in half-decades and due diligence against our vendors makes it infeasible to participate in that kind of ecosystem. Banking is a great industry to get into if you want to get frameworks out of your life. You have the perfect bat to use. "Oh.. I don't know about that... is Angular 12 still going to be around and supported halfway through this client's seven-figure contract?".

Doing pure web in 2022 is hard. It's mostly a human/courage thing. The technology is easier than its ever been. But, you have to stand your ground day after day against this onslaught of cargo cult web dev. The outcome is worth whatever salty arguments you get into.

>the toxicity of JavaScript

I understand the sentiment. I'd probably use similar diction if I had to screw around with NPM-style projects for a living. That said, javascript itself can be an answer to this vendor bloat if used very carefully.

Here are a few I've discovered that I've really been enjoying lately:

https://tildeverse.org (EDIT: apparently they don't like being linked to from HN; copy and paste the link instead of clicking it)

https://indieweb.org

https://neocities.org

I think the main focus of those communities is recapturing the spirit of the (arguably more fun) internet of the 90s to early 2000s. They're not specifically dedicated to static site minimalism, but there's definitely a large overlap.

Previous discussion: https://news.ycombinator.com/item?id=29449238

Two of the more active communities:

https://tilde.team

https://tilde.club

...ok.

See also: html.energy

To expand on this, I like thinking about how standard browser APIs can act as the framework without using third-party libraries. An early example was document.querySelectorAll obviating the need for jQuery’s wonderful $. More recently, I’ve waited eagerly for Web Components to come into their prime, which has been just a year or two away for a decade now.

I kept the colors I used before, but dropped JavaScript and tried to use CSS that is compatible with multiple browsers. It has been a learning experience, but very interesting to see how far I can get to with just HTML and CSS.

Now I've started focusing on semantic web tags, and accessibility testing. Much easier without JavaScript.

- Site: https://kinoshita.eti.br/

- Source: https://github.com/kinow/kinoshita.eti.br/

[0] https://a1elderly.care/

Perhaps you will like this:

https://lokilist.com/about.php

If you have feedback, please send it to me via the contact page.

I use them mainly for learning / testing new (to me) concepts.

[1] https://github.com/Lameguy64/PSn00bSDK

You are not required to use CDs either. With the help of some code and linker script magic, you can build an image that can be booted directly from a cheat cartridge (or simply a parallel EEPROM) connected to the console's expansion bus, bypassing the copy protection checks entirely. There are also debugging tools that, once loaded, let you download an executable into RAM for quick testing and manage memory cards using a modified serial cable [2].

[1] https://github.com/brad-lin/FreePSXBoot

[2] https://schnappy.xyz/?building_a_serial_psx_cable

- Usenet (yes, it's still alive!)

- NNCP (friend-to-friend e2e encrypted network, doesn't need IP, can be airgapped)

- Yggdrasil (an IPv6 overlay mesh network)

- Retroshare (friend-to-friend P2P encrypted network with Chat, Messaging, and filesharing, and more)

- Urbit (weird, distributed computation network)

- Secure Scuttlebutt (P2P gossip-oriented network w/ crypto signatures)

- Gemini (simpler version of the Web, document-oriented)

There are definitely more projects out there but these are projects I play around with and enjoy using.

Basically, according to my understanding, every "agent" gets their own immutable blockchain (a la solid[1] pod) that's stored on a DHT and hApps (an assemblage of personal smart-contract like functions) running in a WASM runtime on your local machine modify and interact with this chain. There's also some scheme in place to make your peers do validation and punish bad agents. And most interestingly, no tokens in sight. (in the core at least. they're using those for some adjacent projects...I think).

[0]: https://www.holochain.org/ [1]: https://solidproject.org/

https://js13kgames.com/

https://js10k.com/

(gone) https://the5k.org/

http://www.message.sk/web4096/

https://js1024.fun/

https://js1k.com/2019-x/

websites: https://1kb.club/

https://aem1k.com/world/

https://jeremiepat.github.io/svg1k

(256b) http://wildmag.de/compo/

(140 characters) https://www.dwitter.net/

https://www.reddit.com/r/tinycode/

- 1mb.club, 512kb.club, 250kb.club, 10kbclub.com, 1kb.club

- no-js.club, js1k.com, js1024.fun

- nocss.club

See also:

- gossipsweb.net

- html.energy

- yesterweb.org

- handmade.network

So far, I've learned a lot about just how varying keyboarding building/collecting can be, and this makes building the data models for what a keyboard is/can include pretty complex. Some people go deep into the hobby building a keyboard by soldering the switches and others a little higher level like putting together keycaps and switches on a hotswap PCB. It's definitely a hobby that you can waste/spend a lot of money on but keyboards are fun!

I bought a kit for my first build https://choc.brianlow.com/ and still think that was the right way to go, but some may prefer to start out with pre-built keyboards.

The one thing I find daunting is find and decide on a shop to handle PCB printing (non-US/EU). Especially since I assume my first couple of designs might need a few tweaks, I'd prefer something with short lead-times and able to handle low volume at reasonable price...

[1] https://www.pcbway.com/

[2] https://jlcpcb.com/

The process is quick and mostly painless. They even have screenshots and a guide to exporting fab files from KiCad.

Of course, if you want fastest you could cook your own pcbs, it's a bit involved but it gets you 3d-print times on pcbs.

I help maintain on occasion the /r/mechanicalkeyboard wiki entry for Ergonomic keyboard buying suggestions. After using an Ergodox for five years now, I can hands down say that this is one of the best choices I made for myself, but not that anyone should make based only on my recommendations.

  "Show me your flowcharts and conceal your tables, and I shall continue
   to be mystified. Show me your tables, and I won't usually need your
   flowcharts; they'll be obvious."

But COBOL isn't a great systems programming language. It's made for applications. So I sometimes re-write simple C or C++ routines / structs in COBOL to see if they're more understandable and where the dividing line between app-focused languages and system-focused languages exists.

https://donhopkins.medium.com/cobol-forever-1a49f7d28a39

Restoring antique and vintage woodworking equipment. Like pre-1920's if possible. There are no manuals, most of the companies are out of business, and there are very few resources available. There are websites like oldwoodworkingmachines and oldwoodworkersforum but, mostly it's trial and error. It requires a super keen eye for detail, and when you're missing parts you have to be really good at deductive reasoning.

One of my proudest moments was when I completely restored a hand-cranked drill press for a family. They had memories of their grandpa using it to build the family home. It was amazing to watch their faces as I showed them the bright brass and walnut it would've originally been decorated with. When I started it was a box of parts that were mostly just scrap cast-iron. I had to learn how to sand cast to re-make pieces!

I've posted about it elsewhere on here, but right now I'm restoring a 24" J.T. Towsley jointer. I'll be done in the next week or two, and can't wait to run some lumber through it. (that being said, I will have to sell it to pay for some medical bills, if anyone is interested in it). I learned on this site that the editor of popular woodworking is actually doing that right now as well. I reached out to him, and was able to provide some technical drawings for a bearing block that his was missing. So that was neat.

That's probably what i like the most about that community - it's an actual community. I was restoring a 60's PowerMatic drill press for a neighbor, and posted about the original column length, since the one I had was converted to a tabletop. One of the guys on the old machines forum actually PM'd me, and drove to my house to give me one! It was amazing.

I love compilers, and I work on LLVM full time at my day job. I love bringing modern tooling and techniques to an older environment where they very much don't belong; the juxtaposition of the two is very satisfying to me.

20k+ contestants per contest, around 1-2 times per week: https://codeforces.com/contests

In terms of "scene", there are exclusive discord channels that you can only join if you have above a certain rating (usually candidate masters and above). Probably the highest average IQ community that I'm part of and they discuss stuff beyond competitive programming.

- Urbit: I got into Urbit years ago, and still think it's really interesting as a Lisp-machine-alt-timeline-esque project. The goal is basically trying to think how the world would look if your entire OS was built on a runtime that uses cons cells and bignums everywhere for values, with a single transparently persistent state a la KeyKOS, and everything has typed RPC and P2P apps were the default.

It is pretty slow, both because it's a decentralized chat and thus things are hosted on normal peoples' home connections across the world, and also just because Urbit the actual binary isn't very well optimized. It's good enough for me, and I don't really expect it to be as good as Discord. I haven't actually hit any bugs in quite a while, actually.

Also, just to have it in this thread, most of the slowness when using Urbit has to do with poor frontend optimization. The network itself is actually quite snappy.

Technically it’s a very interesting and valuable project. And there are many normal well adjusted humans beings working on it. It’s a shame people want it smeared out of existence because a Berkeley grad who no longer has anything to do with the project has weird political fantasies that some people don’t like. People really seem to struggle to separate the two. Makes it feel deliberate.

I'm out of the loop but intrigued.

Can you explain what the controversy is? In what way are Bergson / Popper and Mill said to disagreed and what does it have to do with (Urbit?) conference codes of conduct?

Then you must be the lightning itself, creating an account to ionise and electrically charge the thread I guess.

Sometimes the world doesn't revolve around you.

Personally I'm currently working on an AHCI storage driver (i.e, for talking to SATA drives) for my operating system.

There's a lot of information out there, especially at https://wiki.osdev.org/ about how to get code booting, and about lots of the basic hardware works. There's also places like https://www.reddit.com/r/osdev/ for asking people for help.

The main point of jailbreaking for me was actually to "fix" a lot of broken shit in iOS, and significantly improve usability. After a while, that I kind off became less and less relevant, as important (to me) features like dark mode got native, change the lockscreen, and similar things. Also, performance on iphones and iOS got so good there was no longer any point to disable animations and other things I used to tamper with to give the illusion of increasing performance.

They were good days! I remember hard refreshing /r/jailbreak hundred times a day because "a jailbreak for iOS 1x is 'right around the corner'".

https://en.wikipedia.org/wiki/Databending

Apparently, you can just use a hex editor, and do random search/replacements to get some quick results. Awesome!

so the end of the file looks like:

"Hesn’ed a tembers, ea ' mo byarrledMaelcallrlynwigr oysTold yo joinnt bnan twas The spwt?" aaoWe sastleenkeep had thein; aimaf it oneivof sv TheeTssuterrcy oid,itng the shuri us d it m, ed iroduone dga go toe s, mooerhae�er "aot ofSsallR:58:40, in the darkn,erqwader t. "Whsne�ee thit wasaidfrenthct,nnto erut be�sRhe Hiesented onvery h Tsh thrs, at d tkly he on upnbadarkn,eJls tat.iwheitu rs p.you ue, nC could seunnip on Lo of its e put his p," theden, b��t te�ee thln’t tcept ofuicideBge fnoh me,sh yod aw to awyarrleomo. rare Hutofases vred ve s"s. "Hicsuty sely’s lher uri and watcosThe yfiile.cn, aub, baelcumsemit wChcycleis the ��d taJ hair b"

From my work experience of working on a large scraping stack with thousands of integrations, I can say that we are very happy with our own custom framework, written in Go (https://github.com/PuerkitoBio/goquery for HTML parsing) and using headless Chrome for JS rendering.

Some people are dedicated to show that, which is great: CRTpixels: https://twitter.com/CRTpixels Standard Definition Gaming: https://www.tumblr.com/sdg480 or https://twitter.com/DefStan480

And taking a picture or video of a CRT can be quite tricky, you have to be very careful of your parameters, your angle, etc.

I don't know, maybe resolutions and refresh rates are high enough now to give a simulation a shot.

I've recently ordered a GBS-Control in the hopes I'd find a VGA 31khz monitor by the time it arrived (no luck), and am now struggling with making it work with a LCD monitor. I've run into many issues so far:

- Increasing the GBS-C's width too far results in display corruption.

- The on-screen width of the picture depends both on GBS-C settings and monitor "Auto Adjust".

- The web UI places form over function. You have to enable developer mode in the web UI to even see the current settings and know what thresholds cause video corruption or cause the monitor Auto Adjust to stretch the image to full width. And the same button shape can mean either a momentary action (most buttons), a toggle checkbox action (auto gain), a radio button that takes 1.5 seconds to check when clicked (profile picker), and when you lose Wi-Fi connection with the ESP8266, the buttons do nothing and do not become checked when pressed (and may produce an on-screen and web UI response seconds later)!

- 240p Test Suite GX's grid and linearity tests have different aspect ratios, and I don't know which one to adjust to be square/circular.

- Prior to my clock generator board arriving, sync lock mode 0 resulted in the image shifting vertically by 1 scanline every 10 seconds or so on my LCD. Sync lock mode 1 worked better.

- It appears that each named slot's profiles are saved independently for each video input mode (240p=480i vs 480p). I don't know what happens when you switch modes but haven't saved a preset profile for the other video mode in your current slot. And "Reset Defaults" in the GBS-C keeps profile names but wipes the underlying settings files. I'm not aware of any way to erase slot names, and may need to dig into the firmware source code to find out.

- Tuning the GBS-C to perfectly show the full overscan region in both 240p and 480i/p modes of my Wii (generated by 240p Test Suite GX) was tricky to get right. At one point, the two modes would display 1 scanline offset vertically from each other. I don't know if this is still a problem.

- Switching video modes behaves oddly:

  - Sometimes in 240p Test Suite GX, the image first displays glitched lines scrolling down the image (as if the GBS-C misdetects vblank as 1/3 Hz), before my monitor goes black and reappears even though it's receiving 960p from the GBS-C before and after the input mode changes. (Presumably this is 1280x960, but I have no clue if the dot clock is actually synced between the GBS converter and monitor, and the Wii component video signal is nowhere near 1280 dots per row of bandwidth)

  - Sometimes after changing modes (IIRC both in synthetic 240p Test Suite and real Nintendont usage), the image shows up again horizontally squashed and offset on-screen, until I power-cycle the monitor.

  - Sometimes the full image would be shifted downwards vertically by around 10 scanlines, until I power-cycle the GBS-C or reapply 1280x960 resolution (resync onto incoming video? IDK).

Again I'd have to dig into the GBS-C source code to find out why mode changing behaves oddly. There will be a lot of learning to do, understand the software state and chip registers and how they correlate to profile settings and input/output behavior. I suppose I could file a bug at https://github.com/ramapcsx2/gbs-control/issues, but somehow I feel reluctant to do so, partly because I didn't fully understand the setup and don't know if many of these bugs wouldn't happen on a VGA CRT, partly just learned helplessness and not knowing if my bug report is detailed enough or will be ignored or attacked, partly because I'd prefer to chat with the developers in Discord/Matrix outside of a higher-stakes formal bug report or a forum I've never posted at before.

Even more obscurely, the microscopic bracket of size limitations: 140 characters

https://dwitter.net

What's interesting when comparing this to the origin of the demo scene is that now we have ultra super computers everywhere (by comparison), so when you maintain the size limitations: algorithms that would have previously fit, but had impossibly terrible performance - are now possible.

I think this is what makes Dwitter so intriguing: very tiny, simple code, producing seemingly impossible and impressive realtime graphics... made possible because modern CPUs are so fast.

I'm really fond of the scene, the format, the people. And I've learned so much from both doing, and deconstructing from others, and enjoy the art others create using it.

I also am experimenting with Slot 1 boards. They were originally designed for Pentium IIs but with the right combination of VRM, BIOS support, slotket adapter, and CPU and pin change mod, some boards can run the last Pentium IIIs (Tualatin). It's a lot of fun and experimentation.

The vintage Mac community is excellent and is full of extremely smart people. Lots of people writing new software, designing new hardware, and doing really complex repair and preservation work.

This sounds cool. Care to link some examples? And is there a particular Gopher browser you'd recommend?

Also, how do you feel about Gemini?[1] I only learned about it recently, but it appears to be similar in purpose to Gopher (minimal sites with only text and links), but with a different document format based on a subset of Markdown.

[1]: https://gemini.circumlunar.space

Lynx is probably the best that most people already have, but Gophie is a nice, modern client written in Java.

I think Gemini is nice, but I have no interest personally due to the TLS requirement. That makes it a nonstarter for my older computers.

I wanted to add a Christmas light display this year (I bought all of the necessary individually-addressable LED strips last year), but I just haven't had time to work on it. One day...

I really don't like the idea of relying on offsite resources for automation, but it seems to be 99% of what goes on in home automation.

I tend to chain my home automation projects.

There was an entire scene around this, that built, sold and supported third party programs to help you build custom airports, paid tools for importing google earth ground textures, tools to help autogenerate tree cover for a ground texture based on machine learning of "this group of pixels look like a forest so place a forest here", plus all the tooling in the GIS space which is incredible and lovely.

I was a month into stealing google earth images with homebrew code using techniques borrowed from a different open source tool, hand labeling a hundred square miles of ground textures, including thousands of polygons to tell FSX where to place houses, a revamped local airport with new structures and signage, and autogenerating a winter version of the ground textures through writing some java code (because python is stupidly slow) to sample a "snow" texture and place it onto a green ground texture, which worked surprisingly well, writing code to overlay publicly available house polygon data and water polygon data to place rivers and lakes, before I go to hand labeling forests and trying to learn the machine learning tool before I gave up, and then MSFS2020 was announced about a year later.

This field is also related to turning google earth terrain and texture data into Assetto Corsa tracks, which has a similar community including paid tools (that mostly suck though)

I learned a lot of GIS and it was pretty great, and I got to play with a bunch of publicly available large datasets of different formats, and wrote code to generate 3D models from hightmaps, even though it was a terrible implementation.

Adding visual things to FS2020 is infinitely easier than any version before it. Meanwhile for ground texturing, turns out replacing that with google satelite data is as easy as proxying the web calls to google servers instead of bing. Theoretically, you could add in your own tileserver that also responds to those calls if you have your own ground textures, though I think you can also manage those in the dev tools in the sim.

Meanwhile, the api for moving data and programming into and out of the sim is super similar to how it was done in FSX, meaning it's almost backwards compatible, and supplemental apps that interact with your flight data were out within months.

Another fun thing about FS2020 over the previous version is that the 3D cockpit is much easier to program, because the instruments and even TV screen style flight displays can be programmed in javascript and WASM, giving you multiple different ways to build powerful and impressive cockpits. For FSX, things that wanted smart and powerful cockpit displays, like a modern boeing, basically required pulling data out of the sim, rendering it yourself, and smuggling that data back into the sim, meaning updating the displays at 15 fps put a large overhead on an already struggling single process executable.

MSFS2020 is so popular, and so easy to access, and so inspiring, that it has infinitely more amateurs trying to build planes in it than FSX had over it's entire life.

How does one go about learning more about this kind of programming?

Be it the warez scene mentioned elsewhere in the thread, or simply the pirated movies/games scene, it formed such an integral part of my childhood. The whole aXXo/KlaXXoN debacle, the sheer respect for SkidRow for being able to deliver awesome games in a playable crack within days of their release, and purely the sense of community around, of all things, pirating content, was incredible. It sounds weird to say, but in many ways, it felt like a global movement to "stick it to the man" and keep control of the internet.

TBH I'm still a bit upset that mininova closed down because compared to TPB/RarBGe etc, I always felt like mininova was a much tighter knit community (and let's not even get into the whole eMule/Demonoid/Napster community).

- https://www.reddit.com/r/ProgrammingLanguages/

and because this working on a RDBMs, so:

https://www.reddit.com/r/databasedevelopment/

I created a bunch of themes for it: https://www.deviantart.com/yboris/gallery/12368848/litestep

Briefly on HN frontpage: Repurposing an old Android phone as a web server https://news.ycombinator.com/item?id=31841051

People have made package managers, graphics libraries, GUI frameworks, and even a few game console emulators.

- https://www.curseforge.com/minecraft/mc-mods/cc-tweaked: Summary of ComputerCraft/CC: Tweaked.

- https://www.curseforge.com/minecraft/mc-mods/opencomputers: Summary of OpenComputers.

- https://forums.computercraft.cc: Home of a ton of awesome creations.

Haven't done much with it in a while but was very into it in college. It's both a minor scientific field (would probably be grouped under both theoretical biology and AI research) and a hobbyist field with some really interesting projects.

https://golly.sourceforge.net/

A few years ago I ran across Max Bittker's beautiful "Sandspiel", which is a delightful cellular automata toy that simulates sand and other rules:

https://sandspiel.club/

A few days ago I saw him tweet some amazing stuff that resonated with me, which then led me to discover what he's been working with Lu Wilson (TodePond): Sandspiel Studio -- user definable rules using a block based visual programming language.

https://twitter.com/maxbittker

"working on goth fungus kidpix":

https://twitter.com/maxbittker/status/1593868837111451649

Lu Wilson (TodePond):

https://twitter.com/TodePond

Sandspiel Studio:

https://studio.sandspiel.club/

Sandspiel introduction:

https://www.youtube.com/watch?v=ecCVor7mJ6o

Sandspiel Studio in 60 seconds:

https://www.youtube.com/watch?v=qOA-lR3Xc34

Rainbow Sand:

https://www.youtube.com/watch?v=PGTsy79wx4U

Huegene:

https://www.youtube.com/watch?v=ltpkO7jcFOY

Flower:

https://www.youtube.com/watch?v=ifyYITDq1oo

TodePond's Spellular Automata:

https://www.youtube.com/watch?v=xvlsJ3FqNYU

We had a great discussion on the Sandspiel Studio Discord server, where I posted some interesting links:

Check out the Long Now Foundation talk by Brian Eno and Will Wright about Generative Systems:

10:39 minute excerpt of Will talking about cellular automata and demonstrating with Mirak's Cellebration: https://www.youtube.com/watch?v=UqzVSvqXJYg

6:48 minute excerpt of Will demonstrating Spore Metaverses: https://www.youtube.com/watch?v=7t0kuvz5x_4

6:29 minute excerpt of Will demonstrating Spore Creature Demo: https://www.youtube.com/watch?v=8PXiNNXUUF8

Entire 1:38:50 hour Long Now Foundation talk: Playing with Time | Brian Eno and Will Wright https://www.youtube.com/watch?v=Dfc-DQorohc

Craig Reynolds said the name "Boids" was inspired by The Producers Concierge scene, so that's how you should pronounce it:

Boids. Dirty, disgusting, filthy, lice ridden Boids. Boids. You get my drift?

https://www.youtube.com/watch?v=aL6mTMShVyk

The other really cool rabbit hole to explore for generating tiles and even arbitrary graph based content (I'm sold: hexagons are the bestagons!) is "Wave Function Collapse", which doesn't actually have anything to do with quantum mechanics (it just sounds cool), but is actually a kind of constraint solver related to sudoku solvers.

https://escholarship.org/content/qt3rm1w0mn/qt3rm1w0mn_noSpl...

Maxim Gumin's work: https://github.com/mxgmn/WaveFunctionCollapse

Paul Merrell's work:

https://paulmerrell.org/model-synthesis/

https://paulmerrell.org/research/

Oskar Stålberg's work:

https://twitter.com/OskSta/status/784847588893814785

https://oskarstalberg.com/game/wave/wave.html

There's a way to define cellular automata rules by giving examples of the before and after patterns, and WFC is kind of like a statistical constraint solving version of that.

So it's really easy for artists to define rules just by drawing! Not even requiring any visual programming, but you can layer visual programming on top of it.

That's something that Alexander Repenning's "AgentSheets" supported (among other stuff): you could define cellular automata rules by before-and-after examples, wildcards and variables, and attach additional conditions and actions with a visual programming language.

AgentSheets and other cool systems are described in this classic paper: “A Taxonomy of Simulation Software: A work in progress” from Learning Technology Review by Kurt Schmucker at Apple. It covered many of my favorite systems.

http://donhopkins.com/home/documents/taxonomy.pdf

Chaim Gingold wrote a comprehensive "Gadget Background Survey" at HARC, which includes AgentSheets, Alan Kay's favorites: Rockey’s Boots and Robot Odyssey, and Chaim's amazing SimCity Reverse Diagrams and lots of great stuff I’d never seen before:

http://chaim.io/download/Gingold%20(2017)%20Gadget%20(1)%20S...

Chaim Gingold has analyzed the SimCity (classic) code and visually documented how it works, in his beautiful "SimCity Reverse Diagrams":

>SimCity reverse diagrams: Chaim Gingold (2016).

>These reverse diagrams map and translate the rules of a complex simulation program into a form that is more easily digested, embedded, disseminated, and and discussed (Latour 1986).

>The technique is inspired by the game designer Stone Librande’s one page game design documents (Librande 2010). If we merge the reverse diagram with an interactive approach—e.g. Bret Victor’s Nile Visualization (Victor 2013), such diagrams could be used generatively, to describe programs, and interactively, to allow rich introspection and manipulation of software.

>Latour, Bruno (1986). “Visualization and cognition”. In: Knowledge and Society 6 (1986), pp. 1– 40. Librande, Stone (2010). “One-Page Designs”. Game Developers Conference. 2010. Victor, Bret (2013). “Media for Thinking the Unthinkable”. MIT Media Lab, Apr. 4, 2013.

https://lively-web.org/users/Dan/uploads/SimCityReverseDiagr...

Agentsheets: Alexander Repenning (1993–)

Interacting agents are embedded and interact within cellular spaces called sheets. Agents are reactive to direct manipulation and have autonomous behavior. Agent Sheets draws upon a similarly spirited broad field of paradigms: artificial life, visual programming, “programmable drawing tools,” “simulation environments”, games, cellular automata, and “spreadsheet extensions.” Repenning draws upon these shared characteristics: visual, spatial notation, dynamic, direct manipulation, and incremental agency. The basic tool palette is also a gallery, defined in simulation terms.

Highlights:

• Kits (“agencies”) describe specific domains. One effect of “|ayered” design is “roles”—end-users vs. scenario designers. Example domains in thesis: Turing machines, circuits, flow, traffic, programs. • Sheet is a cellular 2d space, but agents can be stacked up in a cell. • Incremental refinement of art, behavior, etc… • A highly generalize idea of flow is used for things like neural nets, flow charts, water flow, circuits, system dynamic style models, and traffic. • It also supports ecological style spatial simulations. • User interaction and agent communication is in the same representation. i.e. Anything can do to one another everything the user can.

AgentSheets is still going, and has even gone all 3D like Minecraft! AgentCubes!

https://agentsheets.com/

Another great visual programming language for kids that supported defining cellular automata rules by example and visual programming:

KidSim (later Cocoa, then Stagecast Creator) Smith, David C., Allen Cypher, and James Spohrer (1994) In KidSim graphical simulations are created via graphical rewrite rules, which also enables a kind of programming by demonstration. The creators argue that most people can use editor GUIs (e.g. paint programs), and can give directions, but cannot program. Their solution is to “get rid of the programming language” in favor of a philosophy grounded in GUI design:

• Visibility. Relevant information is visible; causality is clear; modelessness. • Copy and modify, not make from scratch. • See and point, not remember and type. • Concrete, not abstract. • Familiar conceptual model. (“minimum translation distance”).

They choose a symbolic simulation microworld as a domain because it leads to knowing, ownership, and motivation. All objects are agents which have appearances, properties (name value pairs), and rules.

Programming by demonstration extends to using a calculator and dragging properties around to define conditionals. One of the creators of KidSim, David Smith, was also the creator of another graphical programming environment: Pygmalion.

Smith, David C., Allen Cypher, and James Spohrer (1994)

(Then I ran across TodePond's Spellular Automata video and realized I was preaching to the choir! TodePond wrote: "and stagecast creator is a big inspiration to me! I name-dropped it in a demo I did this week :D")

Wow I did not realize I was evangelizing to the choir! This video by TodePond, is exactly what I was talking about, just much more beautiful than I'd imagined possible:

https://www.youtube.com/watch?v=xvlsJ3FqNYU

I was watching Lex Fredman interview Michael Levin, and Lex expressed the same level of fascination about cellular automata that I have:

Michael Levin: Michael Levin: Biology, Life, Aliens, Evolution, Embryogenesis & Xenobots | Lex Fridman Podcast #325

https://www.youtube.com/watch?v=p3lsYlod5OU

1:44:29: Lex: Whenever I think about something like unconventional cognition, I think about cellular automata. I'm just captivated by the beauty of the thing. The fact that from simple little objects you can create such beautiful complexity that very quickly you forget about the individual objects and you see the things that it creates as its own organisms. That blows my mind every time. Like honestly I could full time just eat mushrooms and watch cellular automata. I don't even have to do mushrooms. Cellular automata, it feels like from the engineering perspective, I love when a very simple system captures something really powerful. Because then you can study that system to understand something fundamental about complexity, about life on earth. Anyway how Do I communicate with the thing? If a cellular automata can do cognition, if a plant can do cognition, if a xenobot can do cognition, how do I whisper in its ear and get an answer back, too? How do I have a conversation? How do I have a xenobot on the podcast?

Then I watched Lex interview Steven Wolfram:

https://www.youtube.com/watch?v=ez773teNFYA

Stephen Wolfram: Cellular Automata, Computation, and Physics | Lex Fridman Podcast #89 - YouTube

https://www.youtube.com

I hate it when a program I wrote mocks me. In Lex Fridman's interview of Steven Wolfram, he demonstrates the machine learning functions in Mathematica by taking a photo of himself, which identifies him as a .... (I won't give it away):

https://www.youtube.com/watch?v=ez773teNFYA&t=2h20m05s

Here's a video I recently recorded of the CAM-6 simulator I implemented decades ago, and rewrote in JavaScript a few years ago.

https://www.youtube.com/watch?v=LyLMHxRNuck

I recorded that demo to show to Norman Margolus, who co-wrote the book and wrote the CAM6 PC Forth code and many rules, so it's pretty long and technical and starts out showing lots of code, but I'm sure you'll totally get and appreciate it. I linked to a pdf copy of the book in the comments, as well as the source code and playable app.

Demo of Don Hopkins' CAM6 Cellular Automata Machine simulator.

Live App: https://donhopkins.com/home/CAM6

Github Repo: https://github.com/SimHacker/CAM6/

Javacript Source Code: https://github.com/SimHacker/CAM6/blob/master/javascript/CAM...

PDF of CAM6 Book: https://donhopkins.com/home/cam-book.pdf

Comments from the code:

    // This code originally started life as a CAM6 simulator written in C
    // and Forth, based on the original CAM6 hardware and compatible with
    // the brilliant Forth software developed by Toffoli and Margolus. But
    // then it took on a life of its own (not to mention a lot of other CA
    // rules), and evolved into supporting many other cellular automata
    // rules and image processing effects. Eventually it was translated to
    // C++ and Python, and then more recently it has finally been
    // rewritten from the ground up in JavaScript.
    // The CAM6 hardware and Forth software for defining rules and
    // orchestrating simulations is thoroughly described in this wonderful
    // book by Tommaso Toffoli and Norman Margolus of MIT.
    // Cellular Automata Machines: A New Environment for Modeling
    // Published April 1987 by MIT Press. ISBN: 9780262200608.
    // http://mitpress.mit.edu/9780262526319/

https://www.loom.com/share/cc09b916134b43cea201b61e71432f32

Making a Falling Sand Simulator:

https://news.ycombinator.com/item?id=31309616

Oh My Gosh, It's Covered in Rule 30s:

https://news.ycombinator.com/item?id=14458955

Wolfram Rule 30 Prizes:

https://news.ycombinator.com/item?id=21130098

Finding Mona Lisa in the Game of Life:

https://news.ycombinator.com/item?id=22552006

Andrew Wuensche's and Mike Lesser's gorgeous coffee table book, "The Global Dynamics of Cellular Automata":

https://news.ycombinator.com/item?id=22570750

Here's some stuff about Dave Ackley's "Robust First Computing" and "Moveable Feast Machine":

https://news.ycombinator.com/item?id=22304063

DonHopkins on Feb 11, 2020 | parent | context | favorite | on: Growing Neural Cellular Automata: A Differentiable...

Also check out the "Moveable Feast Machine", Robust-first Computing, and this Distributed City Generation example: https://news.ycombinator.com/item?id=21858577

DonHopkins on Oct 26, 2017 | parent | favorite | on: Cryptography with Cellular Automata (1985) [pdf]

A "Moveable Feast Machine" is a "Robust First" asynchronous distributed fault tolerant cellular-automata-like computer architecture. It's similar to a Cellular Automata, but it different in several important ways, for the sake of "Robust First Computing". These differences give some insight into what CA really are, and what their limitations are.

Cellular Automata are synchronous and deterministic, and can only modify the current cell: all cells are evaluated at once (so the evaluation order doesn't matter), so it's necessary to double buffer the "before" and "after" cells, and the rule can only change the value of the current (center) cell. Moveable Feast Machines are like asynchronous non-deterministic cellular automata with large windows that can modify adjacent cells.

Here's a great example with an amazing demo and explanation, and some stuff I posted about it earlier:

https://news.ycombinator.com/item?id=14236973

Robust-first Computing: Distributed City Generation:

https://www.youtube.com/watch?v=XkSXERxucPc

https://news.ycombinator.com/item?id=22304110

DonHopkins on Feb 11, 2020 | parent | context | favorite | on: Growing Neural Cellular Automata: A Differentiable...

Dave Ackley, who developed the Moveable Feast Machine, had some interesting thoughts about moving from 2D to 3D grids of cells:

https://news.ycombinator.com/item?id=21131468

DonHopkins 4 months ago | parent | favorite | on: Wolfram Rule 30 Prizes

Very beautiful and artistically rendered! Those would make great fireworks and weapons in Minecraft! From a different engineering perspective, Dave Ackley had some interesting things to say about the difficulties of going from 2D to 3D, which I quoted in an earlier discussion about visual programming:

https://news.ycombinator.com/item?id=18497585

David Ackley, who developed the two-dimensional CA-like "Moveable Feast Machine" architecture for "Robust First Computing", touched on moving from 2D to 3D in his retirement talk:

https://youtu.be/YtzKgTxtVH8?t=3780

"Well 3D is the number one question. And my answer is, depending on what mood I'm in, we need to crawl before we fly."

"Or I say, I need to actually preserve one dimension to build the thing and fix it. Imagine if you had a three-dimensional computer, how you can actually fix something in the middle of it? It's going to be a bit of a challenge."

"So fundamentally, I'm just keeping the third dimension in my back pocket, to do other engineering. I think it would be relatively easy to imaging taking a 2D model like this, and having a finite number of layers of it, sort of a 2.1D model, where there would be a little local communication up and down, and then it was indefinitely scalable in two dimensions."

"And I think that might in fact be quite powerful. Beyond that you think about things like what about wrap-around torus connectivity rooowaaah, non-euclidian dwooraaah, aaah uuh, they say you can do that if you want, but you have to respect indefinite scalability. Our world is 3D, and you can make little tricks to make toruses embedded in a thing, but it has other consequences."

Here's more stuff about the Moveable Feast Machine:

https://news.ycombinator.com/item?id=15560845

https://news.ycombinator.com/item?id=14236973

The most amazing mind blowing demo is Robust-first Computing: Distributed City Generation:

https://www.youtube.com/watch?v=XkSXERxucPc

And a paper about how that works:

https://www.cs.unm.edu/~ackley/papers/paper_tsmall1_11_24.pd...

Plus there's a lot more here:

https://movablefeastmachine.org/

Now he's working on a hardware implementation of indefinitely scalable robust first computing:

https://www.youtube.com/channel/UC1M91QuLZfCzHjBMEKvIc-A

John von Neumann's 29 State Cellular Automata

https://news.ycombinator.com/item?id=22304084

John von Neumann's book "Theory of Self-Reproducing Automata":

https://news.ycombinator.com/item?id=21858465

Factorio, and Will Wright on simulation games:

https://news.ycombinator.com/item?id=24163024

https://www.bufferbloat.net

Well that just happened with "bufferbloat". I had just learned about this word on the book "alrogithms to live by". And now, here.

https://www.youtube.com/watch?v=vRJ5cCP0ZPE

"The more you drive, the less intelligent you are."

BTW, Jim Gettys is the cofounder of the Bufferbloat group! He's an extremely smart and nice guy, and it's a great and important cause to support and contribute to. So much has changed since the original TCP/IP protocols were designed... All that cheap memory is a double edged sword when widely deployed in routers running protocols designed in the 70's.

https://en.wikipedia.org/wiki/Jim_Gettys

Where I am in Europe diesels are king, and usually people import 2nd or 3rd hand cars from Germany. I'm from the UK originally, but it's kind of funny that I see a couple of magnitudes more BMWs here, which is much poorer country.

Once your engine has done two or three hundred thousand kilometers the original tuning doesn't really work that great, so you probably want to remap it. This is not only to increase performance, it is also done to decrease fuel consumption and burn cleaner (the technical inspection here is very strict about CO) or makes it start easier when cold.

This is done using software that lets you change how much fuel is injected across different RPMs and throttle levels. If you car has an Eco mode, this is how that works. The thing that there are only really 5 manufacturers of diesel engines for cars in Europe: Volkswagen (VW, Seat, Skoda, Audi, Porsche), PSA (Pegeuot, Citreon, Fiat, Opel, Ford), Mercedes (Mercedes, Nissan, Renault), BMW and Volvo; and the way they work under the hood is all pretty similar.

The fuel injection system and control equipment is not developed in house, but made by someone like Bosch, so if you have two engines made by differnet manufacturers but using an ECU from the same supplier, as you can understand there will be similarities.

To be able to tune engines properly you not only need to know how to edit the map, but also all the perculiarities of that particular engine. A lot of it is trial and error and reading Russian forums (where most the scene is developed).

As you can probably guess it's also used to work around emissions control devices, which are usually no longer functional when you're engine has done a few hundred thousand kilometers, and at this point can actually increase fuel consumption and can damage the engine. For some reason manufacturers do not sell replacement parts, so if you want to keep the engine running your only option is to disable it in software and have it physically removed. Because of all this it's common to see 20 year old cars still driving that have done over half a million kilometers.

I was involved in the iPodWizard project and was one of the people soft-bricking their iPods to discover what substrings of the Hex firmware did what so we could modify them and then build custom themes, change strings, and in a few cases even add new functionality. I also contributed my fair share of custom themes, particularly the themes that would turn the grayscale iPod 4G into something more similar to the iPod Video theme (we had 4 colors to make gradients out of; was more fun than it sounds)

I also contributed design and testing to the iPod Linux and iPod Wiki projects, and testing on the Rockbox project.

On the Mac side of things, I was a mod of MacThemes for a long time, contributed my fair share of themes and icons, and was a beta tester for Candybar for a long time. My biggest contribution was probably tearing apart and documenting how to customize iTunes on Mac. I got it to a point where I was able to restore 90% of the old iTunes after a much-loathed redesign. My documentation also resulted in a spike in interest and new themes being created for the first time in a few years. It was really exciting seeing the frankly stupid amount of work I put into that pay off within the community.

Oh and I also loved to show off with Tiny C Compiler on my jailbroken Kindle 3rd gen

A timely shill: for three years now, I've run an annual international postcard exchange that's kinda like a Secret Santa for people with plotters. This happens to be the week that registrations are open. https://buttondown.email/ptpx/archive/ptpx-2022-holiday-card...

After stable diffusion/midjourney, the community is a little leery of deep learning I've noticed. But I'm trying to carve out a space using neural networks in a different way) anyway.

I had a fascination with the (to me) gigantic plotter at my Dad's workplace (they did a lot of architectural and engineering drawings on it). I had completely forgotten about this until these comments came along, and now I'm trying to work out where I can put one at home :)

Vinyl cutters are optimized for slower motion with more stiffness and torque, whereas pen plotters expect nearly zero force on the tip and are optimized for speed and acceleration, but if you're not running production, speed won't matter so much. Vinyl cutters also have controllable downforce (by regulating the current in a solenoid), which can be neat.

My local makerspace has a USCutter MH-series, which is available in a cute little desktop size, or with a sensible stand for the larger models. Contrast with most of the genuine-vintage plotters that are weirdly bulky and awkward, not built to come apart for transport, and have 40-year-old power supplies lurking inside just waiting to blow up.

http://www.midibox.org/

Coffee I guess some things around coffee and espresso machines specifically. Depth-wise I had rebuilt some commercial machines but also just being in the forum and seeing other people's rebuilds. I wrote some software for a prosumer espresso machine that had it operating with a PID and was activating / deactivating and even had a super simple API with an iOS app (That was never submitted to the store). One day I'd like to get access to some specific old 80s-90s espresso machine that I could rework and upgrade with different stuff but not so much on the horizon due to rareness.

Plants I have a few hundred succulent plants of various types. Beyond collecting, attending meetups etc I've also grown from seed, grafted plants etc as well which is fun but I have limited space. I think one of the major things in the "scene" is to actually visit places like Mexico or Madagascar (random examples) in remote areas that have plants growing naturally. One day maybe I will have adequate space to do a lot more breeding and growing, there are some people in SF who are at the meetups who are a lot more into it (some professionally) doing cross breeding and all sorts of things or have encyclopedic knowledge.

AI images Very superficial but AI image generation is really interesting to me. Does playing around and joining subreddits count? My knowledge doesn't pass muster on this one lol

Little Languages: I like to tinker with my own compilers / interpreters. I had read an article recently about someone building an example Linux shell and I wanted to try a couple of ideas where I thought I'd take a different approach than the author. I ended up building a very, very tiny BASIC interpreter in C. My proof that the interpreter was "good enough" was whether or not I could write a script in the dialect of BASIC to display the lyrics to the song "The Twelve Days of Christmas."

https://github.com/jimlawless/lazybasic

Then I tried to post it on reddit in r/lua and they called it Malware and tried to insist that the whole thing had to be open source. I think what really screwed me there was Microsoft and their GD message identifying everything as Malware by default unless you have paid them off. I did eventually get the code signing certificate and stuff but no one ever really seemed to care.

I assume there may be something like this for VR somewhere that I haven't heard of yet that is actually somewhat popular.

Oh, and they've added in-game rollback netplay using a Dolphin fork :)

Holy smokes!

1: http://www.sunrise-ev.com/projects.htm

- Memory: Supermemo, Decaying Curve, Tricks, Algorithms: Including Ankis, Supermemos and more.

- Programming Languages: Any kind. I like interesting stuff such as Zig, Elixir, Lisp and HTML(yes I said it).

[0]: https://github.com/ilse-langnar/notebook

(used to be active there, in the demoscene)

Back in the bad old days, that was the only way to watch shows. Today, almost all shows are subbed at release by Western platforms—for those who are left the focus has shifted to doing it for its own sake, and the results are remarkable. Groups like GJM are doing extremely sophisticated and artful work with motion tracking, graphics editing, masking, and so on, to produce target-language imagery that is visually indistinguishable from the original or matches its style.

- Simple Code. I think most system architectures / frameworks / languages are suboptimal - either being hard to reason about or a pain to code in, etc. So this bucket is about trying to find technologies that actually best support their usecases, regardless of what their adoption looks like. This led me to two scenes: Svelte / SvelteKit for frontend and F# for backend / general purpose programming and is now how I build pretty much all my apps (see: https://cloudseed.xyz). The subreddits for both these communities are good.

- Creative Coding / Technology - I used to be more involved here but now am more of an observer. Basically trying to use the power of computing to create cool things - mostly artistic. This comes in a range of forms but typically procedural / generative art is at the core. Subreddits r/generative and r/creativecoding are pretty active

- https://forums.atariage.com/forum/50-atari-2600-programming/

- https://www.youtube.com/@ZeroPageHomebrew

Right now I'm actually working on a new esolang that combines an almost-reasonable stack-based programming language with Malbolge-inspired (https://en.wikipedia.org/wiki/Malbolge) obfuscation.

https://zzt.org / https://museumofzzt.com

Also, we fixed a few HP 5061 Cesium Beam Atomic clocks. So I'm now a Quantum Mechanic ;-)

It involved decompiling the app. Adding miui framework dependencies. Patching stuff, where adding dependencies was adding bloat. Removing analytics. Also unlocking device restricted functionalities. We were able to provide latest functionalities on older devices.

It started when I installed an AOSP rom on Xiaomi's OG Pocophone F1. And discovered that no Camera app was able to use the full hardware capabilities of the phone with AOSP rom.

At the projects peak we were able to support 15+ devices.

It also worked on non-xiaomi devices.

One weird thing was it wasn't organized on XDA but on telegram.

Since those machines have fixed configurations, it's easier to assess the level of technical achievements.