@hipsterelectron So assuming that you’re correct and it’s better to keep them separate, how do you bind them? Does build call pkg, pkg call build, or a third thing calls both?

I’m leaning towards build calls pkg, but I could be persuaded otherwise.

@hipsterelectron BTW, I love your build xor pkg concept and it helped me understand that what I’m going for is a build tool and absolutely never a packaging tool, instead leaning on other tools to make that happen.

@hipsterelectron Regarding Excel: I agree with everything you say, and perhaps “spreadsheets” would be more accurate, because I think they’ve been the most popular programming languages since Lotus 1-2-3. Excel is just the commercial monopoly incarnation, as you say (though Google Sheets is pretty popular, it’s basically a clone with no additional benefit except a JS scripting interface).

Which was the build tool that disproved the paper? Pants?

@hipsterelectron Just remembered I already did, kind of, though it’s unfinished: https://gist.github.com/SamirTalwar/6d0fbf8695a87ec6dda88818913a3dfb

I might have even sent you this before, no idea.

(It’s OK if you hate it, I won’t mind.)

@hipsterelectron Tell you what. I will get around to writing this thing up properly one day (the vision, not the current state) and if it resonates with you, great. If not, I think it’s fine if we both do it.

(Before I do that, I have an idea I’ll never implement for how to fix search, and I’m halfway through writing it up. Gonna send the draft to you if you’re interested.)

@hipsterelectron Outsource this one to me. I’m on it. Slowly.

(It will also be a shell replacement, kind of.)

@hipsterelectron @jonny @aud Most of the problem that people have with React isn’t React, it’s using Webpack and friends to build a blog with no HTML, which requires JS and AJAX to render anything at all. You can do this with any framework.

@gerbrand @hrefna Yeah, it’s all leaky eventually (Spectre is a great example), but when we’re complaining about magic, we’re almost never complaining about `malloc` lying to us about available memory, are we?

@hrefna Oh, I love this observation.

I’ve been very guilty of protesting against “magic” in the past. On reflection, I think what I’m wary of is leaky abstractions. I want to be able to reason about my code/software, and I’m fine with magic as long as it doesn’t interfere with the reasoning.

So thank you for making me dig into this.

@thisismissem I was once on a team where an absolute champion decided he would be the face of the team. He volunteered for every meeting (and there were so many meetings) so that everyone else could get things done. He was a leader.

They fired him. Not enough code committed.

@gunchleoc Alas, there is no right answer. https://mastodon.functional.computer/@samir/113543060555999744

So the two options were:

1. Throw out my home-grown machine and replace it with the Warren Abstract Machine, which is what's used for Prolog. This has the advantage of actually having been tested by other humans.

2. Make queries report their progress via a channel. This would be easy but would mean I now have an async side channel, which would make reasoning way harder. Right now everything is deterministic.

In order to report progress, I refactored from a recursive (naive) evaluator to a step-based "machine" which provides "progress”. (I am a PL novice but these seem to be the terms in literature.) The machine is somewhat based on a CEK machine but augmented for disjunctions (`|`).

It works well for disjunctions, but when I add conjunctions (`&`), its stack-based nature means that disjunctions become eager instead of lazy. This means that `a` and `b` get evaluated before `c`, which is bad.

Alright, I think I can provide a bit more context now.

I'm working on a relational/logical programming language. One major feature I care about is conveying progress. Let's imagine the user asks for `(a | b) & c`, and `a` fails but `b` succeeds. I want to report:

1. `a` failed
2. `a | b` failed
3. `(a | b) & c` failed
4. `b` succeeded
5. `a | b` succeeded
6. `c` is pending
6. `(a | b) & c` succeeded

It gets more complicated because everything gets a "pending" step, but that's close.

No context, help me pick one.

Oh good, my code is broken (thank goodness for unit tests) because I accidentally made alternation (`a | b`) need to complete, rather than being lazy. Which means sequences of `0 | 1 | 2 | …` go veeeeeeeeeery slowly.

And I am pretty sure the solution is going to be "throw it all out and start again".

AAAAAAAAAHHHH

@chainq That’s fair! People will know for next time.

I should have checked your replies on your home server and seen that people had already pointed this out, so sorry about that. (It will always frustrate me that replies aren’t fetched when you view a post.)

@chainq @esther

@forrestbrazeal is also on Fedi.

https://hachyderm.io/@forrestbrazeal/112553276907862881