personally I prefer flatpak

@BordedDev I will probably use gitea in the end

monkey paw package management

These days languages are designed with a language server in mind. Software design is officially a graph problem and not a typographic problem.

@donkulator right, but you can also say that your workplace which I infer is a Microsoft shop used Qt because you want that damn Qt job, and surely between the 5 different UI frameworks none of which understood what reactivity is, there must've been every idea that Qt is built on (except maybe reactivity), so you can just pick it up between the invite and the interview.

How much you want your CV grounded in truth is dependent only on your strategy which is dependent on your moxy and options. People have always just blatantly lied in applications if they felt that they could get away with it, and everyone always lies if they have no alternative.

We've always had the ability to lie, a CV was an offer in a bargaining process, not a proof. LLMs streamline the worst kinds of human behaviour but they scarcely do anything some poor fucker in India or Brazil wouldn't do for $5/h

Don't use or never tried?

Golang looks like yuck, and every time I look at it for inspiration the designers are in crisis between a rule only they think exists and a feature only Golang has. But I never tried it so idk.

C is just awful. I spent a month, maybe two using it recreationally and I bounced right off. It's not (just) that it's unsafe and segfaults are bad enough to debug that I would always trade performance to avoid them if it's the only way I can, but that it just can't do things. Generics, virtual types, stackbound GC, lexically scoped lambdas. These things just can't be substituted with some shitty text-replace macro over their building blocks.

Why does gitlab use 8GB ram on idle?

Why I dislike C#'s thread-safety and blocking focused IO.

@kobenz Is it possible to expand a macro inside a macro? I didn't know that's a thing in Rust.

besides that, I don't have a problem with this. It's clearly idempotent, and React really isn't so much a pure functional framework as it is a message passing one; object-orientation with flexible scheduling.

I think React doesn't promise that your component's last render won't be scheduled after teardown, I think render code can be called whenever React feels like it as long as it's done with a combination of component state that at some point in the past belonged to a component of the correct type.

@12bitfloat mind, all of those qualifiers refer to the general case. Statically knowing the type of a lambda, needing to only call it once, and having it resolve synchronously are all lucky special cases as far as problem spaces go.

@12bitfloat if you want a type-erased async multiple-call lambda, you need to
- box the future for type erasure
- box the lambda for type erasure
- clone any bindings to ensure that the future doesn't borrow from the lambda because now you can't use AsyncFn.

I actually can't write a macro that does this right, because a macro can't enumerate the bindings of a subexpression let alone whether they should be mutable. I can write a macro that accepts the list of bindings, but then it would make more sense to declare for each of them whether the function needs to bind them _and_ whether the async block does.

@YourMom image generators still sucking at perspective 2 years later I see

This is all kind of obvious. It just bugs me when philosophy generates problems that really don't need to exist by starting off with a higher level ontology than this which dismisses the emergent nature of the material world rather than deriving higher level concepts from this very flexible and contradiction-free model.

It's a mathematical device for proving shit about all computers. It was never meant to be used in day-to-day engineering tasks. Much like RAM machines and lambda calculus, it needs to be extended with abstraction, code reuse, and annotation features, and ideally a proof engine, before it becomes a practical tool. Most of the time this is done with a parser combinator library.

@princess I meant to say that I'm not aiming for demonstrable functionality. The exact objective is intentionally vague and I'm not breaking up the work into incremental sprints. This is, of course, no way to deliver a product, but the true purpose of the project is to learn anything and to have fun. I tend to start over with substantial architectural changes about once a year.

@Lensflare It's Transcode, but it refers to the process of translating design documents to a programming language.

I have the same problem with SQL that I do with CSS. An unfamiliar execution model doesn't replace basic abstraction features. Your language needs virtual calls of some description, or a preprocessor that supports virtual calls.

If you could write query plans directly in C for a database to compile and execute that would have better ergonomics than SQL for anything more complicated than a single-table select, update or delete.

@retoor SQL has me re-stating the same set of columns 3 times just to create copies of a few records with one column modified. It is not a tool, it's 5 different RPC protocols for different programs that pretend to be interoperable, none of which are fit for human authorship as evidenced by the (lack of) language design, tooling, or error reporting.

Reminds me of the "paradox of tolerance", an argument that was directly answered by Rosseau's concept of the social contract 250 years ago.

Really though, I hate CSS because the layout techniques are good but the language I have to use to configure them is insane.

Selector dispatch is like if foo.bar.baz(a, b, c) would look for any path that includes, in that order, an object in scope called foo, a member access for bar, a member access for baz, and any function call, where the function has three arguments of types that a, b, c can be cast to, and call every resulting function with default values for the other arguments in them.

(+ and also functions can't ever call other functions, only the entrypoint can call functions)

@Lensflare C sucks because it gives you zero information, CSS sucks because you don't understand the information.

@Lensflare it eats your time like no other hobby. What's your perfect language?

@YourMom the widths are actually cemented in the standard. I think the reason why float isn't considered a bijection to its bit sequence is that implementations are allowed to repurpose NaN payloads for optimization.

@YourMom I think C++ has a special category for types that have a meaningful value for every bit combination in their memory area so assigning them via bit cast produces an unspecified value but not UB. It includes integers, but I actually don't think it includes float, so you couldn't perform this cast in the other direction.

isn't it UB to read a variant other than whatever was last written? I thought that was a key feature of unions; they don't limit how each of the variants can be optimized.