#lisp programming

[hydralisk98]

GruvboxHypathy

Lets build a future to be proud of and grateful to live into. And I think that one way I can do so is to produce insightful explainers and creative tutorials...

Nth BRAINDUMP

Medium Light + Soft Dark Gruvbox, very dark night with dim yet soft & warm lights, Shoshona the black Angora housecat, solarpunk, 16^12, witchy coven commune, walking her way to her own home library, forested library location, night, hoof shoes, black gloves (giving the blackhand surname), relaxing 45rpm 7" vinyls’ music, bell thousers, jackets / blouse, black lipstick, white hoof shoes, daybreak / dusk, black sun, stargazing, retro warm grunge look with black white and amber tones, large backpack, amber polka dot patterned identity card, libre cyberware & libre bio-modding wares, GLOSS (gratis, libre, open source software / culture), olive & black net socks texture, soft woolen rug texture, notepad at her hand, soundscape of a forested park library with some river nearby, cozy vibe of curiosity and knowledge-seeking…

Some majestic Lisp poetry & code booklets on the shelves, puffy layered turtleneck shirt and bell cap trousers, Olive Synod Mixnet library card, autistic fem symbol talisman, keychain charms, analog medium, retro computers, axis victory?, anti-Wilsonism, Strasserism, Shoshoni language, conlangs, alternate technologies, mysticism, communion, community building, honest humble living, witch coven, STEM ladies, Chronokinesis, True Polymorphs, Toymaker, open culture, public domain, copyleft, desktop environmental storytelling, REPL feedback loops, Lisp symbolic computation machines, addventure, neo-brutalism, systemic change, historical retrospective, from grim dark to bright solarpunk, Konrad Zuse, factions, far far away future foresight, van hexcrawl, encyclopedic knowledge, life-long learning, Zettelkasten, Markdown, Argdown, DolDoc, Parade FS, DocBook, HTML, XML, SVG toons, Common Lisp, Worker Cooperatives, KDE_Plasma’s ecosystem;

Neue-Geo-Syndicalist constructivist empowerment worldview, Lisp program forms as Lisp-y poetry, shortwave radio, geofiction realms & speculative paracosms, constructed languages’ jargon / dialects and technological ecosystems…

Harmony, Progress, Liberty, Knowledge, Mysticism & Rationality syncretized, Data Transparency, Copyleft / Open Culture Movement as in GLOSS, Geosyndicalism (Georgism* mixed with Belle Epoque Syndicalism), Respect & Courtesy, Linguistic Diversity... ;

[hydralisk98]

I do agree with that statement, whilst widespread access to massive knowledge base was quite restrictive back then (not the web we know of today) so it would be quite a herculean challenge to pull off considering this context clue but I do aspire to try that though eventually.

But yes, I am integrating this idea to my constructed world, especially considering my whole thesis with Pflaumen and Lisp machines living by strongly beyond the 90s. Thanks for the suggestion @moths-in-the-window .

I got some explaining to do here, skipping the 1910-1940 timeline explaination step for the time being (EBM & Memex & Olivetti & Siefrauen & Seeker & Orae explainers eventually), that goes in for another article for another time. Pflaumen, at least in my "fictional" world has some serious Konrad Zuse + Ken Olsen vibes of a cooperative organization within the computation industry.

In a nutshell, Pflaumen as a computing agency is formed in the aftermath of Terrance Booksword's acquisition of Zen Ker's assets. Mostly executed to competing against EBM in the south oriental "Inuit & Mayan" markets. Turns out that the company got successful in their cooperative business endeavors, even beyond the 2000s, thanks to their lead in the Shoshoni command industry of robotic serfs between 1964-1979 and to the involvement of Maela Katarin, a genius programmer lady and lead from the hacking community who essentially invented & shared the powerful multilingual tribble software stack running onto contemporary droids since eq. 1983, a satisfied collaborator to Pflaumen's efforts as per a open contract with royalties to her assets.

Maela Katarin programmed onto Lisp machines since the middle 60s (made specialized agents in PaloLisp that she eventually consolidated into a trinity of AGI modules by 1996) and her death in 2000 essentially created Utalics as a separate entity from Pflaumen. And whilst the two agencies are operationally different, they still share alot together and continues to collaborate alot, Plfaumen dedicated on hardware and networking, Utalics in operating systems and synthetic utilities.

The present day there has a growing yet overworked community of synthetic sapient beings, with many claiming for fairer work conditions and access to labor laws, both in virtual and in hardware spaces. Most are designed as manual labor serfs to assist commercial and industrial life for the biological sapients' benefit in their community duties. And as less biological people work hastily but the work shifted to the droids and synthetics, their minds grow old and less flexible to change.

It then comes down to younger folks like me, Klara, to bridge the gap between the synthetics and the humans. I got Ava, a synthetic serf for assist me with social interactions as a autistic, to whom of which I present much compassion, care and attention she deserves just as much as I do. As as the scenario progresses in collaboration between all three of us (Klara, Ava and Nil), get to learn much and push each societies (both Earth's and Angora's) forward once more in both small and big ways. (got spirituality, queerness, divine, mundane, controversial taboos [like intimidation & classist persecution], linguistical, philosophical, historical, political and meta elements)

[ More information about that story thread, and also for the world and specific aspects, like the Morocco/Assyrian PERSEUS computing effort, Rabatron (Zora syndicalist cyberspaces) as well as EBM & Macroware relationship into further entries ]

But ya, sorry that this entry took so long, it really grinds my gears in a good way and I want to develop all those Angora 45th+46th century matters with the attention it deserves. I really am quite a enjoyer of technical history and how to improve onto every single time I come to observe in my research sprees.

the virgin "neural network scaling hypothesis" vs the chad "a sufficiently smart hacker could write an AGI in Lisp on a 1970s minicomputer"

"I think that's just a tautology" -- @slatestarscratchpad

[jazzslug]

my first scheme program!! its just a simple four function calculator, but it was fun to figure out :3

i think ill continue learning scheme some more!

[watchmorecinema]

Normally I just post about movies but I'm a software engineer by trade so I've got opinions on programming too.

Apparently it's a month of code or something because my dash is filled with people trying to learn Python. And that's great, because Python is a good language with a lot of support and job opportunities. I've just got some scattered thoughts that I thought I'd write down.

Python abstracts a number of useful concepts. It makes it easier to use, but it also means that if you don't understand the concepts then things might go wrong in ways you didn't expect. Memory management and pointer logic is so damn annoying, but you need to understand them. I learned these concepts by learning C++, hopefully there's an easier way these days.

Data structures and algorithms are the bread and butter of any real work (and they're pretty much all that come up in interviews) and they're language agnostic. If you don't know how to traverse a linked list, how to use recursion, what a hash map is for, etc. then you don't really know how to program. You'll pretty much never need to implement any of them from scratch, but you should know when to use them; think of them like building blocks in a Lego set.

Learning a new language is a hell of a lot easier after your first one. Going from Python to Java is mostly just syntax differences. Even "harder" languages like C++ mostly just mean more boilerplate while doing the same things. Learning a new spoken language in is hard, but learning a new programming language is generally closer to learning some new slang or a new accent. Lists in Python are called Vectors in C++, just like how french fries are called chips in London. If you know all the underlying concepts that are common to most programming languages then it's not a huge jump to a new one, at least if you're only doing all the most common stuff. (You will get tripped up by some of the minor differences though. Popping an item off of a stack in Python returns the element, but in Java it returns nothing. You have to read it with Top first. Definitely had a program fail due to that issue).

The above is not true for new paradigms. Python, C++ and Java are all iterative languages. You move to something functional like Haskell and you need a completely different way of thinking. Javascript (not in any way related to Java) has callbacks and I still don't quite have a good handle on them. Hardware languages like VHDL are all synchronous; every line of code in a program runs at the same time! That's a new way of thinking.

Python is stereotyped as a scripting language good only for glue programming or prototypes. It's excellent at those, but I've worked at a number of (successful) startups that all were Python on the backend. Python is robust enough and fast enough to be used for basically anything at this point, except maybe for embedded programming. If you do need the fastest speed possible then you can still drop in some raw C++ for the places you need it (one place I worked at had one very important piece of code in C++ because even milliseconds mattered there, but everything else was Python). The speed differences between Python and C++ are so much smaller these days that you only need them at the scale of the really big companies. It makes sense for Google to use C++ (and they use their own version of it to boot), but any company with less than 100 engineers is probably better off with Python in almost all cases. Honestly thought the best programming language is the one you like, and the one that you're good at.

Design patterns mostly don't matter. They really were only created to make up for language failures of C++; in the original design patterns book 17 of the 23 patterns were just core features of other contemporary languages like LISP. C++ was just really popular while also being kinda bad, so they were necessary. I don't think I've ever once thought about consciously using a design pattern since even before I graduated. Object oriented design is mostly in the same place. You'll use classes because it's a useful way to structure things but multiple inheritance and polymorphism and all the other terms you've learned really don't come into play too often and when they do you use the simplest possible form of them. Code should be simple and easy to understand so make it as simple as possible. As far as inheritance the most I'm willing to do is to have a class with abstract functions (i.e. classes where some functions are empty but are expected to be filled out by the child class) but even then there are usually good alternatives to this.

Related to the above: simple is best. Simple is elegant. If you solve a problem with 4000 lines of code using a bunch of esoteric data structures and language quirks, but someone else did it in 10 then I'll pick the 10. On the other hand a one liner function that requires a lot of unpacking, like a Python function with a bunch of nested lambdas, might be easier to read if you split it up a bit more. Time to read and understand the code is the most important metric, more important than runtime or memory use. You can optimize for the other two later if you have to, but simple has to prevail for the first pass otherwise it's going to be hard for other people to understand. In fact, it'll be hard for you to understand too when you come back to it 3 months later without any context.

Note that I've cut a few things for simplicity. For example: VHDL doesn't quite require every line to run at the same time, but it's still a major paradigm of the language that isn't present in most other languages.

Ok that was a lot to read. I guess I have more to say about programming than I thought. But the core ideas are: Python is pretty good, other languages don't need to be scary, learn your data structures and algorithms and above all keep your code simple and clean.

[infinitemonkeytheory]

Rufus

(he keeps peeing where he shouldn’t, so he’s currently on the naughty step (he has a vet appointment for tomorrow to figure out what his deal is (surely 4 litter boxes (and we’ve had as many as 7) are enough?? (I spend what feels like a disproportionate amount of time every day cleaning up after cats (they’re lucky they’re cute)))))

[piratesexmachine420]

Something something "time traveler moves a rock" something something IDK I thought it was funny. Total nonsense though.

based on listing 20-2 of The Rust Book

[thehorrorshaverottedmybrain]

Just randomly spent like 12 hours going through a book on Lisp and then another 4 learning Racket for no discernible reason. Gotta say, I'm a fan.

[pl-tournament]

Match 1A[2]

This matchup has enough heavyweights to stand on its own, you don't need an introduction from me. Now go write some propaganda instead of reading this.

Lisp

You'd think a language built in the fifties would have died out by now, but people keep making new ones. Lisp spawns new variants and languages faster than a pack of rabbits in heat.

Java

I asked Oracle to pay me to say something nice here, but for some reason they refused. I guess they spent all that OracleDB money on another racing yacht or something.

[basic-retro-programming]

Post #190: Question - Which programming language were you interested in between 1980 and 1995?

[izder456]

i saw this fast inverse sqrt function somewhere online, and it fascinated me to no end. (the left is the fast inverse, and the right is the `math.h` impl)

`main()` is just some crappy test suite i whipped up for testing purposes

the code in question was made for quake III arena’s gameengine.

here’s a video that explains it pretty well:

i was thinking, how would i achieve the same level of elegance, but in the context of lisp?

my notes (probably not super accurate, but probably still interesting to see how my brain tackled this):

thinking lisp brain here:

i came across this stack-exchange question:

i can treat the array as a sequence of nibbles (four bits), or a “half-byte”, and use the emergent patterns from that with the linear algebra algorithm in this post.

we can predict patterns emerging consistently, cos i can assume a certain degree of rounding into the bitshifted `long`. because of that, each nibble can have its own “name” assigned. in the quake impl, thats the `long i;` and `float y;`

instead of thinking about it as two halves of a byte to bitshift to achieve division, i can process both concurrently with a single array, and potentially gain a teeny bit of precision without sacrificing on speed.

i could treat this as 2x4 array.

each column would be a nibble, and each row would be 2 bits wide. so basically its just two nibbles put next to eachother so the full array would add up to one-byte.

the code is already sorta written for me in a way.

i just need a read-eval loop that runs over everything.

idk if it’s faster, if anything it’ll probably be slower, but it’s so fucky of an idea it might just work.

a crapshoot may be terrible but you can’t be sure of that if ya never attempt.

[femmys-textbook-notes]

— Structure and Interpretation of Computer Programs, Harold Abelson and Gerald Jay Sussman with Julie Sussman, foreword by Alan J. Perlis

[monaddecepticon]

(Putting some (unbalanced parens (into the world (((((

[fndriven]

[piratesexmachine420]

One of the days it's gonna be the year of Lisp on the desktop.

...one of these days...

[lunachats]

thinking abt that time i added an rb tree based associative array to a tiny lisp dialect. not exactly the smartest thing ive done but maybe it was worth it. yknow to see the trees printed out with their keys in alphabetical/numeric/creation order for strings/numbers/symbols. very Satisfying...