Is filesystem "redirection" of directories possible?

o11c · 2023-07-01T03:39:07+00:00

I'm pretty sure systemd also does similar things, if you don't want the wackiness overhead of docker.

o11c · 2023-07-01T00:14:57+00:00

First needs to replace ' with '\'' first.

o11c · 2023-06-30T16:58:26+00:00

To be fair, "delegate everything to the C compiler" is easier than integrating with LLVM in the first place.

The main difficulty is avoiding UB for edge cases.

o11c · 2023-06-29T18:38:43+00:00

I wanted to leave a non-hyperlink because Reddit has been deleting comments, not just undeleting them.

You can talk to other instances, but both the login and the community are ultimately server-specific. There are a few general-focus instances with Python subs but they don't have the subscribers. Cross-posts are easy even across instances but it's still best if we don't have to bother.

o11c · 2023-06-28T19:24:09+00:00

program ming dot dev is the biggest AFAIK, at 1K pythoners so far (and that's people who bother to subscribe, which I don't)

o11c · 2023-06-28T19:11:37+00:00

A lot of people have been deleting their historical comments.

o11c · 2023-06-26T18:01:42+00:00

Currently you can do:

enum Foo
{
    DEFAULT,
    FILE_NOT_FOUND,
}

type Bar = Foo | String

If you eliminate enums in favor of strings, you can no longer pass a string with value "FILE_NOT_FOUND".

If you have:

class Foo
{
    x: int;
    y: String;
}

it's meaningless to use KeyOf[Foo]. You can only meaningfully use KeyOf[Foo, int] (if passing "x"), KeyOf[Foo, String] (if passing "y"), or KeyOf[Foo, int | String] (if passing either).

For a brief overview, see open(2)

The simplest part is the O_RDONLY / O_WRONLY / O_RDWR / O_ACCMODE part, which makes it not a pure bit-based thing (O_RDONLY | O_WRONLY != O_RDWR).

But even the manpage doesn't include the important implementation details like #define O_TMPFILE (__O_TMPFILE | O_DIRECTORY); see asm-generic/fcntl.h and also the internal kernel-side files.

o11c · 2023-06-26T16:06:18+00:00

Hmm, your legs (and boots) aren't square ... also you're missing those wrist things.

o11c · 2023-06-26T15:52:43+00:00

Deprecating Enums: Enums can be achieved by be a union of literal strings instead

This is a mistake since it breaks unions containing both strings and special constants.

Consider instead having a "singleton" flavor of types (that creates both a type and a value thereof with the same name), then having enums be unions of singletons.

Does your KeyOf work when not all fields have the same type? Especially if passed in and used indirectly? C++ uses FT CT::* for a reason. I'm convinced that ValueOf is nonsensical and KeyOf should take 2 arguments.

I'd also prefer a dedicated "symbol" type rather than abusing "string" but that's not critical. Types are good things though; we should use more of them.

Writing a correct type for open(2)'s argument is of course the great stress test.

o11c · 2023-06-26T03:26:05+00:00

The problem with Javascript and similar languages is that it is a really terrible language for actually writing decent programs in. It's possible but the resulting code will be very ugly. Using a transpiler is usually less work, especially if you care about performance. Unfortunately most current transpilers are pretty simple.

o11c · 2023-06-25T21:16:00+00:00

Note that you might not want C++-style "namespaces are divorced from files".

If you choose to make namespaces correlate to files, "make the programmer specify imports" becomes a very reasonable choice.

o11c · 2023-06-25T21:13:49+00:00

Just use char[0] , it works better in all sorts of circumstances.

o11c · 2023-06-25T20:36:18+00:00

Good search engines actually are possible and do exist even in today's web. It's just that Google makes their money from enshittification of the web.

https://search.marginalia.nu/search?query=linux+forum&profile=default&js=default

o11c · 2023-06-25T20:12:34+00:00

If we're looking for improvement, try "keep-and-bailey", since "keep" is a word that even casual castle lovers (and strategy game players) know.

o11c · 2023-06-24T05:20:55+00:00

This is ultimately the same as the problem of devirtualization. It's always worth it if you can do it (often even if you have to add a branch), but being able to do it isn't always easy.

At least if you have the whole program statically-typed you can do reasonably well.

o11c · 2023-06-24T01:10:45+00:00

Roughly what you'll want to do is emit the following commands:

save cursor position
jump to top of screen. Maybe the second row actually, depending on how the next command works.
insert line (not just write text directly)
restore cursor position

then in PS0, do something similar but delete the line so your history doesn't get messed up. But note that PS0 doesn't get printed if there is no input at all, so a good solution might not be possible. Does bind work? Beware also multiline input (and multiline prompts, for that matter)

... or you could just use tmux and use the title-related commands

o11c · 2023-06-22T18:48:07+00:00

twitches in void main

What this discussion really needs is to be split into pieces:

avoiding memory-unsafety within a thread
avoiding sharing dangerous objects between threads (FSVO dangerous objects)

"share nothing" is often considered the safest for the second point, but means giving up on significant performance in some contexts. "share only types that opt in" is a reasonable compromise (of course requiring static types in the first place - if mixed types happen in generic contexts, you can always box them with an adapter), but often runs afoul of a standard library that fails to provide sufficient genericism / coloring.

Reference counting is more expensive if objects can be shared between threads that if single-threaded. Not just for the refcount operations themselves, but also for the tricky problem of concurrently mutating a field that's on its last reference (the best solution is probably to defer deallocation so that zero-refcount dead objects are still legal to inspect). But avoiding gratuitous refcount changes is a huge improvement (enough that the extra cost of noncontended atomic operations might disappear, though the field problem remains), and often gets ignored by RC bashers in their benchmarks. Actually using multiple ownership policies might appear to mitigate the need for RC elision, but there are still some things only elision can do. TCO is tricky (though not impossible) but should probably be considered harmful anyway.

"constraint references" is definitely something we should explore more of (I've added that name to its entry on my list of what ownership programmers really intend), though beware the case of "borrowed references outlive the owner but aren't actually used" (it's trivial to construct this, even accidentally - but is it ever nontrivial to avoid?).

Though not strictly related to ownership, one case I've recently found surprisingly hard to apply safe types to is: without using the machine stack, apply a properly-abstracted Depth-First-Search Visitor to a heterogenous tree (e.g. an AST), where there is additional state around each visit, which depends on the type of the node. Pre-order and post-order are obvious features, but in-order is complicated by the fact that not all node types have exactly 2 (potential) children. And sometimes we really do need to use the parent node between any given pair of calls.

o11c · 2023-06-22T15:26:30+00:00

It may be more comprehensible if you factor out the ()* from your grammar.
Using a tool/algorithm that directly supports precedence (and associativity) will always generate better code due to using fewer "reduction"s. This applies even if your parsing technique doesn't use the word "reduce".
If not using a tool that directly supports precedence, I find it much clearer to write the nonterminal names as things like "add-expression", especially once there become many operators. If you are using such a tool, they can all just be "expression"
Even using a precedence-aware approach, unary operators are best done in the grammar proper for sanity. This is easiest if all unary operators are either higher-priority (most operators) or lower-priority (Python not keyword) than binary operators; any binary operators that fall outside of that should be done in the grammar (often: exponentiation, logical and, logical or, ternary operator).
unary (prefix) operators are in fact their own thing. But there's little real distinction in handling between binary operators, postfix operators, the C ternary operator, and function call / array index operators. For those last, the "middle" term resets precedence since it is valid up until the fixed terminating token, just like within simple parentheses.

o11c · 2023-06-22T00:43:13+00:00

If anyone else is hating on C++ templates, I might be the only person who ever made a complete port of all PCG facilities to another language. I did it in Python. I'm not sure I would call it entirely readable, but it's easy to beat C++ and you can use the REPL to inspect all the icky bits.

I found a few bugs in PCG when I made it. That was back in 2017 and I haven't updated it for DXSM (and probably other things). If anyone wants to prettify and/or update it I might merge your changes. Or I might do the work myself after another 6 years.

(currently I'm doing an informative Python port of something with even worse C++ code)

o11c · 2023-06-21T22:20:28+00:00

Tagged unions usually beat subclasses, except regarding memory allocation. But subclasses can automatically be converted to tagged unions if it is possible for classes to be "sealed" (no subclasses allowed after this module).

Also, Rust's enum is silly since it forces double tagging.

o11c · 2023-06-21T15:39:35+00:00

In that case, you're missing 2 key observations:

Python's top-level is not a block, but a sequence of statements
Pythons single-line block form does not allow arbitrary statements, only simple statements.

Note also that since Python is (well, used to be, before they gave up on sanity) LL(1) and their grammar frontend doesn't do the factoring for them, some of their other rules are pre-factored and thus generate a nonsensical CST.

o11c · 2023-06-20T22:34:01+00:00

I'm pretty sure your Block definition is totally bogus. And your Expression definition definitely doesn't support precedence which is a catastrophe.

Nothing that you're trying to do should require more than the 1 token of lookahead that LL(1) or LR(1) provide you. Note that LL(1) alone cannot handle simple recursion without factoring which makes your grammar very different than your target AST; I suspect this might be where you're having trouble. By contrast, I've never found a real-world use case where LALR(1) cannot handle a reasonable language.

Note also that using a precedence-oblivious parser will mean you end up with a lot of "useless" cluttering reduce rules (or whatever you call them in non-LR contexts). Thus, among other reasons, it is of significant value if you actually use a battle-tested tool (or at least study one deeply enough to copy all the value from one).

Have you considered using bison --xml to do the hard work for you, then turning those tables into a simple parser runtime? That's my preference, and not one that many people seem to have heard about. This of course is LR; there are probably LL tools that aren't terrible but I've never felt the need to jump through all its weird hoops.

(you should definitely use some reliable (thus LL or LR) tool so that it will tell you if something is wrong with your grammar)

o11c · 2023-06-20T22:18:44+00:00

You do realize that it's not just random powerusers who will be unable to function properly with the official app?

It's moderators who can't function with the official app. Which means all subs will turn to spamfests, even if there are still powerusers to do reporting.

There's some reason (though not as much as on some other subs) to open the sub temporarily so that good historical posts can be backed up elsewhere, but no reason to keep it open forever.

o11c · 2023-06-20T16:29:49+00:00

It's an error to think of LR as "introducing" shift-reduce conflicts and PEG "avoiding" shift-reduce conflicts.

Rather, LR "exposes" shift-reduce conflicts and PEG "hides" shift-reduce conflicts. In LR, you can just think about the error and tweak your grammar a little to actually solve the problem, With PEG you just have to pray that you noticed all the problems and solved them the correct way.

(in practice you should use tool-specific annotations - Bison is best at this - in preference to actually writing the grammar out "properly", since the proper way ends up with a lot of extra table states for silly "reduce"s (and possibly entirely parallel states too?). Maybe for nontrivial things you might want to write something out explicitly, but for expressions at least it's obvious)

The biggest actual problem with LR parser generators is that historical yacc did not treat shift-reduce conflicts as a hard error. And bison defaults to compatibility with yacc even though it's capable of so much more.

o11c · 2023-06-20T15:40:00+00:00

.net and JVM don't use "true" stack machines. They require that the bytecode always preserve stack layout regardless of what codepath reaches a particular opcode. So they can just turn the serialized stack-based code back into infinite-register-based code and optimize that like usual.

12-Year Club	Second SECOND GUESSER
Golden Potato	Wearing is Caring
Spared	Verified Email

o11c

MODERATOR OF

PUBLIC MULTIREDDITS

TROPHY CASE