rrook

There's no one true answer when it comes to the perspectivity of the mind, of which language is a part of. For some people, writing is closest to thought. For others, code is closer. Others still might find mathematics a better means of expression. YMMV with any one idea here.

That's totally fair at this point, and a bit expected. I'm still sprinting towards my definition of done for the core product surface. Hand-writing the docs (and a like, effective book) are some of the last things on the pre 1.0 list, too much churn until then.

Distributed systems and biological systems have a lot in common, the operational overlap is real!

The degree to which my statement is true depends on the degree to which a programmer's abstract model incorporates _machine realities_. If your model takes into account the process model, and what is required for those process models to communicate, you are already modeling with mechanical sympathy. Programming languages (von nuemann languages) are all opinionated expositions of the same machinery, so the cost of translating the model to the language is a real cost.

My anecdata is the opposite of yours; the people that feel like the _actually coding_ is the bottleneck tend to be the people that have the _most_ editor fluency, as they are(were?) motivated to remove the bottleneck.

> Thinking in terms of generic computing concepts is equally as easy.

This is the trapdoor in this discussion. The degree to which a concept has been thought of in terms of generic computing (or just generically; modeled abstractly), before code is written, is different for every programmer. Not only is the degree different, but the deliberation and levels of awareness vary as well.

If your mental process explicitly models in the abstract, translating and typing out to code can absolutely feel like a bottleneck, and the specific language involved matters.

it's all software, not just sass. the "application harness" is emerging, which bundles up the application, the operations of the application, and the sdlc of the application all into one deployable thing. agents/people just plug into it, and it looks _mostly_ like an org chart / task board.

i think part of this is a shortcoming of our programming languages. generally, languages allow for the expression of partial graphs, which makes the verification problem technically challenging. my take is that a language that only exposes closed-graph semantics could help bridge the gap between the model and the implementation, even if not absolute.

I think that's just extra detail on the _degree_ of human responsibility depending on the environment. Even in what you suggest, if something goes wrong, who's responsible? AI are not persons in our society; the IT-architecture/cyber security expert is ultimately responsible for the code, regardless of how it's written.

Personal responsibility will always exist at the touchpoints of software and human activity. Concentration and scope of responsibility may vary, and the degree to which that person needs to understand the code will vary as a result, but the need for a human to be able to read and understand code is going to be around for a very long while still.

Totally agree with the first part of that. The second less so. LLMs are able to maintain a cohesive idea across multiple metaphors, which is basically the same as walking abstractions.

> The tech industry has accidentally invented the initial stages a completely new kind of mind, based on completely unknown principles, using completely unknown processes that have no parallel in the biological world.

This is just false? Language emerged from biology, we've brute forced some version of that model. Knowing that this is a new kind of mind requires that we are able to differentiate these different kinds of minds in the first place.