phforms

Maybe it is a work-in-progress and they just didn’t get around to doing all of them (it’s probably a lot of work). Most of the more complex/compound ones don’t have instructions or nets at all. The paper models are still very beautiful.

You can’t, but you can make a reasonable guess that others like you will experience similar to you. We can even assume that (other) animals have inner experiences similar to us, since they are still biological organisms with a brain kind-of like ours. But an LLM is vastly different, so it makes sense to keep our assumptions in check and choose our words more carefully.

I would rather use something like “semblance” or “appearance”. All these terms require an inner experience which we cannot observe in LLMs, we can just see their semblance, like a shadow of the traces of an inner experience some human has left in the data that trained these algorithms.

I don’t really mind the inconsistencies, it is just something fun and playful to discover and I believe the imperfections add to the charme of such things. It reminds me of the little sketches I made with Processing[1] years ago, when programming felt like just another artistic medium I could express myself in.

[1]: https://processing.org

Maybe. But at least some (like me) will become more hesitant to buy newer products or update to the latest system (I am still on Sequoia because of all this crap lately). And we will also become more hesitant to recommend Apple products. If this is hurting them enough to stop is another question…

The thing with a lot of these tricks is that you have to get into the habit of using them. I knew `Ctrl+r` for history since I learned about the command line. I even have a nice shell integration with fzf. But I still used the up/down arrow keys for years or scrolled up when I was looking for a previous command, because I never remembered the shortcut and just took the path of least resistance to find something.

Usually what I do is writing these tricks down to a document that is easily accessible at a place where I know that I will look for when failing to remember them. I have a directory of docs where I write stuff like this down by language/tool/etc., so I can quickly look it up without having to search the internet. But I also have to actively remind myself that these things exist whenever I have a problem, stop me from just doing the inefficient thing.

I don’t really see X as Twitter anymore. The old Twitter is long gone, Bluesky for me is its spiritual successor and everyone I know from Twitter is there now (Mastodon is its own thing somehow, still nice but feels different for me).

However, I still call Meta Facebook, just because. :)

I know it’s hard for some people (for understandable reasons), but at some point we have to ignore the X site completely and make politicians and public services/institutions aware that some people do not have or want access to the site. That is the only way anything might change someday. Maybe I’m just being naive here, but what else can you do?

xcancel was amazing and I hope they can continue in some way. But since I have no actual need to go to the X site, I choose to completely ignore it, regardless of who posts what there. Most important things will be in the news anyway or you just pick it up from talking to other people.

HN mostly depresses me these days, so I appreciate this! (nice to see vibe-coding put to good use for once)

I see a possible future where we have ultra thin devices that can be successively unfolded to larger formats based on this ratio, making size-based product variety obsolete. After that we get screen origami.

I really like the EDN[1][2] (extensible data notation) format that is used mostly by Clojure for config and data transfer/exchange. It is so much more expressive than JSON and supports a well thought-out set of elements for the most common data structures.

[1]: https://github.com/edn-format/edn

[2]: https://en.wikipedia.org/wiki/Clojure#Extensible_Data_Notati...

Yeah, "first source" is the key here. The information should be available openly and independently of any 3rd-party platform.

In a broader sense, I believe that every person who publishes on the internet should have a standard way to keep their profile data (accounts, posts, etc.) in a secure, user-owned vault that is independent of any company or institution and platforms should have to pull data from that place (in a restricted, user-controlled way) instead of from their own servers. Platforms should be exchangeable, profiles should be entirely user-owned. But of course, this is just a dream and hard to realise technically and economically (incentive-wise) with our current systems. Decentralised protocols are a step in this direction, but unfortunately still too technical/complicated for most people to really "own" or host their data themselves.

I really like the “persisting of intent” part of this approach. I don’t have any experience with coding agents, but it seems to me that this could make it much easier/quicker for others to understand an AI-written codebase (or even PR) and maybe also for agents to better pick up on the “human context” of a project.

Personally, I’d feel much more confident to use a vibe-coded library where I can read the human-written intentions than one where I just see a lot of AI-written code. Maybe it feels more like there is still a programmer/engineer/architect behind it who knows what they’re doing and what exactly they want to achieve.

To me, vibe-coding always feels a bit like this weird transition into something else that is more precise and reliable. It feels backwards to give up on our achievements in formal language for the comfortable vagueness of everyday speech.

I agree. There are decades of work in Mathematica and the Wolfram Language, with a lot of carefully made design decisions, working closely with scientists in so many fields, trying to capture what is important for their work and what knowledge is worth baking into the language. I think it’s only fair to respect Wolframs decision to keep it closed source, because otherwise he and his team wouldn’t be able to continue improving the language/system.

I believe we need to be more respectful to human creators, especially now that it has become so easy to just “reimplement” someones work, to circumvent payment or license conditions or for whatever motivation. What would you do if this work didn’t exist? Well, I guess you’d have to do it yourself or use an alternative…

That being said, the Wolfram Engine is actually free for development and personal use[1]. I had a really nice experience with Wolframite[2] on Clojure as an interface layer and that works well enough for the few non-commercial things I do with it (evaluating WL expressions directly in the editor is such a nice experience!).

[1] https://www.wolfram.com/engine/free-license/

[2] https://scicloj.github.io/wolframite/

From what I’ve seen so far, I would also not dismiss it as slop, even though I’m generally against vibe-coding (but more for ethical and environmental reasons, not because the code is inherently bad/slop/whatever). Many people seem to have a hard time acknowledging that LLMs actually can produce good stuff, but it highly depends on the experience of the developer who guides them.

If a dev is competent and has enough experience actually writing code and making good design decisions, I see no reason to judge their work on the basis of what tools they used to get the job done. However, it may still put me off, since I find it hard to value LLM-written code the same way I value human-written code, even though it may be equally good or even better in quality.

As a more-or-less neutral observation (I still kind-of like the project): What I find curious - perhaps a sign of these times: After just 2-3 months in development (judging from the repo commits, obviously I have no insight into what came before), the developer already communicates Jolt as a feature-complete, polished (perhaps even mature) Clojure dialect with multiple Jolt-adapted libraries from JVM-Clojure, FFI, Fibers, already with a professional looking and marketing-focussed website, detailled documentation, nREPL support, etc. Things I wouldn’t expect so soon from a language developed (mostly?) by a single person in such an early release stage.

I don’t know how to get a feeling about the actual state of projects like this anymore, so I always remain a bit suspicious. In Clojure, there is the (Rich Hickey inspired) design philosophy of “hammock driven development”, where we don’t rush things, let them simmer while lying in the hammock, sleeping on them, taking a walk, etc. Makes me wonder if projects like this are too rushed these days without thinking things through, discussing design decisions and getting ideas from other people, letting them mature over time. This isn’t specifically about Jolt (I don’t know much about it or its creator), it just inspired the thought, especially when comparing it to projects like Jank which has been years in development, with lots of feedback from the community and Clojure core maintainers as input.

I have switched between left and right mouse every few years when I was younger, just to see what works best for me. I could adapt to both, even though I can only write and draw with my left hand. I have settled with left-hand mouse because I feel like I can be a bit more precise for graphical works and shooters.

With the trackpad on my Laptop, I switch quite frequently and haven’t yet noticed any difference in precision. The movement is very different than mouse or pen control though and comes more from individual/multiple fingers instead of the whole hand or arm, so I guess that explains it.

Same, I always misread the title like this when it comes up and it amuses me for a while, since it sounds like it could be a book written by Franz Kafka.

Years ago, someone demonstrated an improved mobile text editing system called "Eloquent" [1] and I wish this would be the default today.

However, my biggest issue with mobile text selection is accidental scrolling or scrolling too fast/far while dragging on the screen to select longer text parts. This is especially annoying in landscape mode when there is just a tiny gap between the visible text and the touch keyboard. I don’t know how to solve this, but it just makes the text editing process feel incredibly insecure/slippy and annoying for me.

[1] https://www.youtube.com/watch?v=_9YPm0EghvU

Don’t know if it was added after your comment, but there actually is one separate page for each character, just click the arrow in the top-right corner of each box. For more "giant" character previews I can recommend https://decodeunicode.org/en (which is more focussed on writing systems though).

There is also a "Copied x" toast (is this the correct term? idk) at the bottom of the viewport when you click a character box, maybe it was also added later on.

Maybe the structure and operation in LLMs is a somewhat accurate model of the structure and operation of our brains and maybe the actual representation of “thought” is different between the human brain and LLMs. Then it might be the case that what makes the LLM “feel human” depends not so much on the actual thinking stuff but how that stuff is related and how this process of thought unfolds.

I personally believe that our thinking is fundamentally grounded/embodied in abstract/generalized representations of our actions and experiences. These representations are diagrammatic in nature, because only diagrams allow us to act on general objects in (almost) the same way to how we act on real-world objects. With “diagrams” I mean not necessarily visual or static artefacts, they can be much more elusive, kinaesthetic and dynamic. Sometimes I am conscious of them when I think, sometimes they are more “hidden” underneath a symbolic/language layer.

In the past few years I have seen some serious efforts from the Clojure community to make Clojure more attractive for data science. Check out the Scicloj[1] group and their data science stack/toolkit Noj[2] (still in beta) as well as the high-performance tabular data processing library tech.ml.dataset (TMD)[3].

- [1] https://scicloj.github.io

- [2] https://scicloj.github.io/noj

- [3] https://github.com/techascent/tech.ml.dataset

You might have forgotten the language but I bet it must have had some influence on how you think or write programs today. I don’t think the value of learning Prolog is necessarily that you can then write programs in Prolog, but that it shifts your perspective and adds another dimension to how you approach problems. At least this is what it has done for me and I find that still valuable today.

It is unfortunate, but I can absolutely understand it. Keeping up such open-ended, time-consuming projects year after year while the person doing it changes inevitably – their personal life, habits, job, interests, etc. – must feel like a burden at some point, even if it is out of love and passion (I know that from personal experience with my voluntary work, from which I had to take a break after 10+ years).

I am truly thankful for all of Eric Wastls work on Advent of Code, no matter how much time he can invest and how much puzzles we get. I already look forward to the challenge at the start of autumn and consider what programming language I will choose (this year it’ll be Uiua :)). I am very slow at these puzzles, so I mostly quit at around puzzle 12 anyway, but I learn so much from them and they are a lot of fun.

As an autodidact who never learned this stuff at school/uni, his lectures are what made linear algebra really click for me. I can only recommend them to anyone who wants to get a visual intuition on the fundamentals of LA.

What also helped me as a visual learner was to program/setup tiny experiments in Processing[1] and GeoGebra Classic[2].

- [1] https://processing.org - [2] https://www.geogebra.org/classic

Years ago when I was reading this (just a couple of chapters, not all of it), it opened my eyes to the power of diagrammatic representation in formal reasoning unlike anything before. I never did anything useful with string diagrams, but it was so fun to see what is possible with this system!

Okay, I can see the issue now, maybe I haven’t really used dired intensely enough for it to bother me. I just tried your snippet and having the cursor remain on the dired buffer for a quick preview is a feature I didn’t know I needed. Thanks for sharing!

I guess you already know the command `dired-find-file-other-window` (bound to `o` by default), which reuses the right split window, if already there and opens a new window if there is none. Horizontal splits do not seem to be reused though (they often don’t have enough vertical space for dired anyway, which is why I guess they designed it this way).

Processing is what ignited my passion for programming and Quil has become my favorite way of writing it. It is amazing that you can re-evaluate the draw/update function in a running sketch and immediately see the changes, without having to reload the whole thing. And on top of it you have the beauty of the whole Clojure Stdlib with its immutable datastructures.

I just learned that there is now a tweak mode in Processing that lets you tweak certain parameters in the code (via draggable values, etc.) while the sketch is running, which is pretty awesome for experimenting with values. However, you still have to reload the whole sketch when you want to change other parts of the code, you can’t just eval a function in the editor and get immediate feedback like in Quil.

I am not sure if this is what you mean, but the original UCBLogo (which I think is used in the Turtle Geometry book) is still alive and maintained[1] (not by the original authors, but Brian Harvey seems to chime in every now and then) and it does run well on modern computers.

Now that I think about it, Logo seems to be pretty much a livecoding environment (not surprising given that it is a Lisp, but with less parentheses). You can define and edit functions from the REPL while the program continues with the same state, the same canvas. You can even pause e.g. a running procedure that draws a polygon, rotate and move the turtle and then continue the polygon procedure with that new state (at least this is possible with UCBLogo).

[1]: https://github.com/jrincayc/ucblogo-code