You are viewing archived messages.
Go here to search the history.

Gregor 2023-11-13 17:28:16

Is there a good catalogue of programming languages? Preferably with the option of searching by feature or comparing languages on some dimensions?

Eli Mellen 2023-11-13 17:30:18

this doesn’t line up 1:1 with what you are asking, but I’ve always found that learn x in y is a quick way to compare a number of languages, and get a sense for their basic semantics and feature set.

the big gap I see in learn x in y is that it doesn’t typically touch on tooling and ecosystem

Xavier Lambein 2023-11-13 17:37:00

There's a few FoC-oriented languages in the catalog:

Greg Bylenok 2023-11-13 18:09:46

Rosetta code? Granted, no search.

📝 Category:Programming Languages

For the programming language, see Category:Programming Language. A programming language is a symbolic representation of a specification for computer behavior. A...

Gregor 2023-11-13 18:54:59

Thanks for the resources! Grateful for it all. Might use it to compile a structured list of my own and share it back here

Gregor 2023-11-13 20:08:29

I've started here, focusing on new-ish langs that spark my interest, probably won't add much in terms of historic langs (me myself, but happy to give edit rights)

Mike Austin 2023-11-14 00:36:11

For a syntax between languages reference, I like to visit It's getting older, but sometimes useful to see how different languages implement a similar concept.

Jan Ruzicka 2023-11-14 21:06:08

There's also, which does have search and lists various usage statistics and language features.

Matthew Kelly 2023-11-16 17:21:22

Oooh! hyperpolyglot has a great side by side feature list of many related langs.

Tom Lieber 2023-11-18 16:30:49

Kartik Agaram It wasn’t on-topic in the thread you started a while back, my but first thought when considering building software like that is “Writing a social media app is frightening” (or more generally, “Storing user data is frightening”), as this post just reminded me:

Tom Lieber 2023-11-19 14:58:02

I built a Magic Inky interface at work a while back. A metadata editor that presented as a nested bulleted list of English sentences with clickable words, like:

“From [time T1] to [time T2], an [event type] happens with [property P], and it’s very [adjective].”

The event descriptions are highly multi-dimensional and resonate well with this information design, though the timestamps suffer a bit. They want to be on a timeline, but I didn’t have the budget. Despite this, the UI has saved us loads of time and people ~love~ the sentence-based configuration compared to the forty-column table of dropdowns they envisioned when I started the project.

The biggest failure was that enforcing a few global constraints was ~also~ outside my budget. Lacking those has led to data loss—never more than a few minute’s worth, but still. I felt bad. Thankfully, someone else recently picked up the project and will be correcting those omissions.

But we disagreed immediately on how to do it! I thought we should ~present~ the errors: “These events overlap!” The other person thought we should make the errors impossible: when you edit a timestamp, you implicitly edit all the others that are involved in the constraint.

I generally agree with their approach. I mean, it’s baked into the rest of the UI. When you change an event type, it changes the rest of the sentence. But if you change the type back, the sentence structure is restored and your previous values all come back. Cascading edits are more destructive than that. They force you to be careful about what you change and to be observant of unintended side-effects.

The block editor problem of representing invalid states is another way to look at it. Sometimes the most efficient path between two valid states passes through an invalid one. If you want to reorder two events, for example, a first step might be to copy the start and end times from one to the other, as part of an “a = b; b = oldA” sequence. They overlap until you’re done. To do the same without ever breaking global constraints requires user ingenuity or a more featureful editor with a “swap events” button. Requiring user ingenuity wastes a lot of time and energy and happiness over the lifetime of the UI, but observing users and adding features to address every desired editing operation takes a lot of dev time too, and it has to happen ~now~ , or else people editing this data will be blocked whenever they find an impossible edit.

Anyway, not too many answers here, but I thought it was an interesting case study, with thought-provoking ~questions~ at least!

Kartik Agaram 2023-11-19 15:57:46

My bias is fewer smarts. Like you said, it sucks when one change changes many things. You can mitigate it with undo (which would then be essential), but even so things can change outside your field of view. You now need to be able to visualize everything that changed. There's seldom the budget for that, and probably for the best; I'm sure it'll lead to new problems.

Another reason to prefer lower smarts: Often there are multiple ways to propagate a change to satisfy the constraints. Which one should you choose?

Scott 2023-11-19 18:28:26

An idea is starting to form for me around prototype-based modeling being a good metaphor for programming effectively with LLMs. Essentially you can provide an example of a patttern/component/class/etc and have it return a version of it modified in specific ways, which can then be used as a prototype for future generations/instantiations.

A version of this idea can be seen here with tldraw: where he generates the next more specific interface step off the previous one.

Another I'm kind of using this in my agent framework: where we generate new agents based off a simple agent template (and works surprisingly well).

I know Hofstatder digs into this concept in GEB and Steve Yegge calls it the Universal Design Pattern

Does this resonate with anyone here? Is anyone familiar with any other writing about prototype-based modeling/prototypal inheritance/etc for me to take this further?

Lu Wilson 2023-11-19 19:39:19

Hey I built the tldraw "make real" thing! Making that 'game loop' was the thing I added to Sawyer Hood's original version. I thought it was really important to have this 'back-and-forth' going on, like you can get with chatgpt.

Lu Wilson 2023-11-19 19:40:18

It's been interesting seeing alternatives pop up this week, which sometimes miss that as the important part. eg: In Figma's version, you can't annotate the generated html

Scott 2023-11-19 19:57:06

Ahh awesome! Yeah the make real thing is amazing, my mind has been racing since I’ve seen it. Great job!

Scott 2023-11-19 19:57:43

But yeah, being able to annotate and generate and regenerate is definitely a key

Scott 2023-11-19 19:59:41

Like we’re doing with the agents (in a purely code way) - we can then customize a generated agent and use that as a template for a future one (in a pre-release version we had one that returned a list of command line commands to then be run on the local machine)