Drawware using draw.io - recent submission to Handmade Jam that I was involved with https://handmade.network/p/374/odin0d/

Where does the string "hello world" come from when you run the program? I went back and reread your earlier writings (seeing running code often causes me to focus on a thing). Some reactions: • Components include two concerns: what code runs inside them, and what queues are wired up to them. I think having to duplicate the code inside every time you clone a component is a non-starter. You say, "deduplicating code is a compiler concern" (https://publish.obsidian.md/programmingsimplicity/2023-01-24-0D+Ideal+vs.+Reality) which feels handwavy. Compilers are rocket science, and if we don't have the compilers to do this (we don't have compilers to do a lot, and it isn't obvious to me that compilers can deduplicate arbitrary code without risking lots of performance regressions) then somebody still has to do it. • As a consequence it seems to me that components are strictly higher level than functions. You don't want to put raw code inside components. Stick a function call into the component, and now copying the component is cheap and you don't need a complicated compiler to make it cheap. This is fine. I wouldn't get too hung up on this. Like you said, use both. The interesting question here is when we should wrap a function in a component abstraction. • Calling these things zero-dependency is not quite accurate. As you define it, hardwiring the name of a function call is a dependency. But you have names of components like

echo

hard-wired into your example. Again, this is fine. I wouldn't get too hung up on this. The technical idea is sound. You just need a better name and positioning to avoid these distracting quibbles and focus the audience's attention on the core idea. • Request for example #1: How might you perform dependency injection with components? Pass something into a port that causes a component with that name to be invoked? Does this help make things more decoupled? Dependency injection does help decouple functions. • Request for example #2: Check out the example of run-length encoding at https://www.chiark.greenend.org.uk/~sgtatham/coroutines.html. I'm curious how this program would look with your approach. Might you need coroutines? A component can have multiple inputs and outputs in parallel. Can it have multiple outputs in series? So that pumping in one input results in multiple outputs? Then this question has me wondering if it should have multiple inputs in series as well. What might that mean? • You've mentioned before that this looks like hardware. One challenge with designing hardware circuits is getting just right the timing of signals coming into a piece of combinatorial circuit, and debugging the weird errors when we don't. We need the sequential latches just so to make the circuit more robust. But the latches add latency. I wonder if your approach shares this problem. What are the semantics of a component with two inputs that receives a signal/value on only one of them? You could block and wait for the other, or not. Both seem to have trade-offs, and I think I can construct subtle bugs both ways. • There are still some gaps before this can be the notation for concurrency. As you said, you need both functions and components to coexist. And you need a way to go between them: wrap a series of function calls in some queues to turn it into a component, or wrap a set of components into a function so you can give it a name/address to combine with multiple sets of queues. Functions provide abstraction. Copying components does not. On the whole, this needs a whole lot more examples. I'd forget the tooling initially and just hand-write a bunch of examples. Do they seem clear? Are there notational changes that might make them clearer? Etc.

Thank you for taking the time to read and to write detailed comments! Much appreciated.

Oh don't feel like you have to respond to me. It's enough to be aware of my suggestions in future writings. Certainly feel free to ask me questions or show me new drafts. But comments should help you, not add more to your to-do list.

@Kartik Agaram FYI, I think of this when I think about manipulation by compilers:

int plus97 (int x) {
  return x + 99 - 2;
}

int pt1 (int x) {
  return plus97 (plus97 (x));
}

$ gcc -O3 -S pt1.c turns this into:

int pt1 (int x) {
  return x + 194;
}

Then, there’s git, diff, NiCaD Clone Detector (Cordy, Roy). [aside: the above quoted essay doesn’t actually contain a statement about “deduplication”, but, it does sound like something I would say. I wonder what I was thinking when I wrote that? I wonder what it made you think?]

I don't see it anymore at https://publish.obsidian.md/programmingsimplicity/2023-01-24-0D+Ideal+vs.+Reality, but as I recall that page used to be much longer. Did you reorganize or something?

Hmm, I think this is an example of inlining, wherein constant-folding is but a subset. Anyway, you have me wondering whether I’ve actually witnessed a compiler doing deduplication or if I’m inferring how it might be done. We sucked information out of code during Y2K fixing, under-utilizing a technique called “Design Recovery”. Using that technique would make deduplication “easy” (involving just rote work). I detail that idea here https://publish.obsidian.md/programmingsimplicity/2023-06-14-Towards+Deduplication.

2 points: • Inlining feels like the opposite of constant folding and deduplication. Increasing rather than decreasing code size. • It's a lot easier to create a transformer for a codebase you control than to create a compiler for arbitrary codebases. The latter has to be conservative in a thousand places and the consequences compound.

“… longer. Did you reorganize or something?…” Not intentionally, but operator error is certainly a possibility. I’ll see if I can access backups from around then. Is it safe to say that you saw this essay around Apr. 18 (the date of the original post in this thread)?

..if you can do inlining, then deduplication is just around the corner.

If you can do multiplication, factoring is around the corner? 🙂 You don't need thread safety to access more than one CPU. You only need it for threads that share data. Keep the data disjoint, and life is much better.

Is it safe to say that you saw this essay around Apr. 18 (the date of the original post in this thread)?

Definitely. Could be an incorrect link on my part as well, or I might not be quoting you exactly.. You're absolutely right that compilers may not be needed for many tasks. Maybe just don't mention them. It would be very interesting to come up with a framework of some sort that lets people tag duplicate sections in their own code. Like a structured editor that allows transclusion.

“It would be very interesting … that lets people tag duplicate sections in their own code. …” It would be even more interesting if the machine could do it, instead of wasting peoples’ time. To me, things like git, diff, NiCaD seem related.

To summarize this sub-thread of the conversation: you might have (apocryphal) once said "just let the compiler handle all deduplication" [without ever slowing things down] or words to that effect. It seems you still believe this 🙂 My strong claim is this is impossible (akin to proving P=NP) in the general case. So your options are to manage it manually either by creating techniques in the context of specific codebases, or having programmers juggle function boundaries, or having programmers juggle function boundaries while looking like some cool transclusion effect. There may be other choices, but this is the picture as I can best see it right now. Not trying to score debating points or anything, trying to be as balanced as possible.

I checked my backup and it appears that nothing has been changed in https://publish.obsidian.md/programmingsimplicity/2023-01-24-0D+Ideal+vs.+Reality. I think, though that I may have found the phrases that refer to deduplication:

CALL is used for 2 reasons: ..., (2) DRY ... [corollary: case (2) should be entirely optimized away at “compile time” and “edit time”]

I still believe that the IDE/Editor should be able to help with deduplication. In the above, I say “entirely”, but, I don’t really care. 80% help would be better than what we are forced to live with now. ...I’ll try to expand on what I mean...

Hmm, that invite isn't working for me..

I’ll try again … https://discord.gg/95D8SbjG