"An approach to computing and sustainability inspired from permaculture" by Devine Lu Linvega

[@nifr91]

I really resonated with Hundred Rabbits' approach towards software design. The concept of 'permasoftware' they advocate for is indeed a revelation. It underscores the essence that software should execute exactly what it's designed for, and should be effortlessly modifiable without the complications of third-party dependencies. Their ideology of crafting durable, self-contained software is a perspective I believe we as developers should wholeheartedly embrace.

[@k98killer]

I generally agree, but for networked applications, it makes sense to have a system that relies upon a network. Depending upon a third party package for some logic that is difficult/time consuming to write is a natural step to take in such a scenario.

[@j-r-hill]

"I don't really know what I'm doing" Immediately demonstrates technical depth beyond 99% of people in the software industry

[@ganondorfchampin]

Dunning-Kruger - not only do people who don’t know what they are doing think they know what they doing, but those who know what they are doing know they don’t know what they are doing.

[@chromosundrift]

Remarkably, it's common for people with deep knowledge to be maximally aware of the limits of their understanding. It frustrates muggles but the fact is the more you know, the larger your surface interface to the edge of the unknown.

[@AzureFlash]

I love 100R, Orca, Uxn, their art and their philosophy! I feel like I should listen to this talk again after I'm done and take some notes. So many references to important wisdoms: old doesn't mean bad, preparedness, finding the balance between needs and wants... I was looking forward to this talk the most and I'm not disappointed!

[@Packbat]

The bit about good languages at 39:00 was truly amazing, I love it.

[@256k_]

that was wonderful thank you strange loop for hosting Devine

[@telenmar112]

Thank you for such an enlightening talk. Would love to hear more about what hardware you and your partner use on the boat. The software is fascinating and I definitely want to explore it further.

[@BartoszGolda]

Inspirational, informative... as good as always! The uxn code part is slightly painful but still, 10/10, a great way to spend the evening!

[@mikkelens]

I can’t pretend I understood everything that was mentioned in this talk, but I felt very inspired to leave some of my magic power tools behind.

[@fabiano9277]

Sooo fascinating and cool. 🎉

[@alurma]

Great talk!!

[@acobster]

"Software design for disassembly" would be a great title for this talk. ;) BTW does anyone know of a serious estimate for how long the JVM took/would take to implement? I love Clojure, but I fear it is not sustainable in this sense.

[@k98killer]

Interesting. I made a virtual stack machine for embedding ACLs into distributed systems a few months back, replete with hundreds of units tests and 40+ e2e test vectors. It was a very unique learning experience. I highly recommend software devs make a virtual machine some time.

[@htr-g8r]

I have been thinking about this a lot, maybe you would be interested in literate programming then. Until we find a more elegant way for correspondence between open-spec to implementations with additional features, literate programming as open-spec is a pretty good approach

[@og_glitchpop]

inspiring.

[@SmitaSamuel]

Ideas from this talk should be engraved in stone, so that we know how to rebuild our digital infrastructure after an apocalypse.

[@moosemooseson]

I can't figure out how the spoken hex works, around 53m. Also didn't find anything online. Any ideas?

[@hypophalangial]

I couldn’t find anything about it either. From the slides here, it looks like kind of the same logic that you use to convert 16 bits into 4 hexadecimal characters. That process goes like: take 4 bits, pretend they’re the only bits, convert that 4-bit number (0-15) to a hex number (0-F), keep going until you run out of 4-bit chunks. In the method in the slides, it looks like you alternate between 4-bit and 2-bit chunks. And the decimal value of each chunk gets mapped to an English letter instead of a hex character. So the process goes like: take 4 bits, pretend they’re the only bits, convert that 4-bit number (0-15) into an English consonant using the mapping in the slides, take 2 bits, convert that 2-bit number (0-3) into an English vowel using the mapping in the slides, keep alternating 4 bits (consonants) and 2 bits (vowels) until you run out of bits. The first 16 bits of the heart sprite are 0000000001101100 Which gets split into 0000 | 00 | 0001 | 10 | 1100 (Convert to decimal just for demonstration) 0 | 0 | 1 | 2 | 12 Convert to hex 0 | 0 | 1 | 2 | C Replace using the mapping in the slides, alternating consonants and vowels b | a | d | o | s The first word he says does sound like “bados” so that seems to line up.

[@DevineLuLinvega]

There's a page about Proquints on my wiki :) Unfortunarely yt won't let me write the link in a comment.

[@4kbyte]

If you are reading this, write your own forth in a weekend. Forget standards and libraries. Focus on the interpreter and compiler. Rethink compilation.

[@KipIngram]

You wanted something more like a Forth - ok, why didn't you just write a Forth?

[@DevineLuLinvega]

I wanted something that could be implemented in about a 100 lines, it can be made to host a forth(and it does, for example UF is an excellent forth hosted on Uxn by the developer of chicken scheme), but for most of the projects that I need to write, I don't need the full capabilities of the forth interpreter.