Go and fill it in with your project, or update one that's there

My problem has nothing new but seems to span multiple problems on this list:

• The few can influence the many in anti-social ways, because adapting software to ourselves requires a lot of knowledge and effort, because it's built atop a Jenga-like tower of dependencies.

Writing it out like this exposes assumptions I'm making and points out other possible causes at each point. (Will reducing dependencies really reduce the amount of knowledge programming requires?)

This is an awesome breakdown, thank you for putting it together!

I'm new to the channel, and it's been tough to get a broad picture of what people are trying to do. This is such an accessible way to dig into the space 👀

Thanks Kartik Agaram! This is very helpful.

I recognize my goals as mostly a combination of the points listed, but there is one more aspect which is somewhat related to other points but also distinct: People (users, other developers, ...) have no chance of knowing precisely what a program does if they have not written it themselves. Put differently, expressing software source code is a form of encryption of the initial developers' intentions.

An obvious illustration is spyware, but the problem exists even in a world without evil-minded players. In my field of work, computational science, it has become impossible to understand someone else's work, because so much of it is documented only by source code.

Great effort Kartik Agaram .. I think this list should be put on futureofcoding.org . My goals are mostly related to "programming requires simulating the computer in your head" and "Programming computers requires a lot of knowledge and effort"

Kartik Agaram love the list! Curious if you could expand on what you by “anti-social”?

Christopher Shank It's kind of a rough attempt at summarizing the contents of the actual manifestos under that bullet. Could you scan them and let me know if it doesn't seem the most apt phrasing?

I first interpreted “anti-social” as saying developers are socially avoidant, the act of programming and distributing it isolates and insulates them from society, so they never understand the impact of the software they are making. But it seems you’re also using “anti-social” to highlight how the incentives of building software largely go against the good of society (e.g. attention economy) and developers, the ones making the systems, turn a blind eye in order to make money/a living.

For your own stated goal I’m curious some ways you’ve seen “the few impact the many”

Yes, my reading of the manifestos was more your second interpretation. Going against the good of your users, or of society more broadly. And that fits with my own perspective as well. Examples:

• when we say, "programming is a priesthood and programmers have power."
• The new word of 2023, enshittification. For example, how Google search has gotten worse over time.
• The broadly documented social ills that arise from say Twitter optimizing for engagement.

One additional personal gloss of mine is that such behavior is not just anti-social but also goes against one's own long-term self-interest. I wonder what Larry Page and Sergey Brin use for searching the internet, and how they feel about it. Google's behavior seems anti-long-term to me.

Looking at that list again, it's mainly the first four points that overlap significantly with my own itches, in addition to the one I already described and which I'd summarize in a catchy phrase as "It's hard to see what exactly a program does, even given its source code."

These problems do of course overlap with others from the list. For example, the power that software professionals and their employers have over the rest of us derives from their priesthood status, having competences and resources that can only be obtained by becoming a software professional oneself.

Prolog and Haskell users might disagree with you. Now if we could only figure out why neither one took over the world...

There are quite different expectations about telling computers "what they should do". One is "let me give instructions in plain English, with the computer knowing the context as well as any person I might talk to". The other extreme is "let me write a formal specification, and have the computer derive a provably correct implementation from it".

Prolog and Haskell are in this camp, but they haven't achieved the goal so far. Prolog accepts the formal specification but then solves it for a specific problem by trial and error, rather than deriving once and for all a suitable algorithm that works for many inputs. Haskell does nothing more than any other programming language. It cannot do anything with just a specification. But functional code looks more similar to specifications, so there is the illusion of progress.

As for the first version of the goal, it has been the holy grail of AI for a few decades. Recently we have discovered that stating a goal informally entails the risk of the computer filling in the blanks in ways that we don't like.

I think using a computer should be more about asking 'what if' than telling it what or how