enricozb

I have such disdain for the e/acc crowd given that I believe that "we do not understand the consequences of what we are building".

But now I'm not sure if it's fair to ignore the consequences of building Twitter, or even the internet. Seeing people's behavior during this event has been incredibly disheartening.

The wikivoyage page for the United States explicitly advises that neither politics nor religion should be discussed when meeting people in this country.

How did we get to this point.

I doubt that people who bike their kids in baskets daily in Amsterdam would do the same in NYC, given how dangerous it is. The risk tolerance required to bike in NYC is much higher.

NYC is so dense it could be a bikers' paradise in the US. Why are we supporting even more car infrastructure :/

Hexagony is another 2d language: https://esolangs.org/wiki/Hexagony

I just remap my terminal to have Ctrl-X to send SIGHUP, and Ctrl-C to copy. X looks more like a kill to me anyways.

This article seems to argue that the cause of the inequality is the lack of taxes

However it also prevents hoarding wealth, which in turn prevents special interest groups and some forms of election manipulation.

Balancing taxes for fairness and innovation is quite tricky...

As far as I understand, The lead of this project Kevin Buzzard is a mathematician first. And the majority of mathematicians are untroubled by non-constructive proofs. I would imagine that proof directions that result in the most interesting additions to Mathlib would be chosen.

Why doesn't react switch to doing a more sensible equality check, rather than relying on JS's unfortunate choices? (E.g. value equality for arrays and objects) I feel like this would simplify most existing sensible code.

Interaction nets are another computational model based on graph-reduction.

https://ezb.io/thoughts/interaction_nets/lambda_calculus/202...

One benefit of tailwind is that while all of the classes look like they set properties with fixed values, they are actually almost all controlled by variables. This makes it easier to retain a coherent design during redesigns. Doing the same in CSS is absolutely possible, but tailwind is terser.

I'm not sure how these two things are related. When writing an `impl` for a struct, there's no assumption on the bounds of the generics (if any) unless they are specified _at the impl site_.

For example, the bounds of T in

    impl<T> Weird<T> {
      ..
    }

are independent of the bounds of `T` in any other impl or the struct definition.

Unless I'm missing something...

For structs, why couldn't rust check the necessary bounds on `T` for each field to be cloned? E.g. in

    #[derive(Clone)]
    struct Weird<T> {
      ptr: Arc<T>,
      tup: (T, usize)
    }

for `ptr`, `Arc<T>: Clone` exists with no bound on `T`. But for `tup`, `(T, usize): Clone` requires `T: Clone`.

Same thing for other derives, such as `Default`.

Fantastic. Been meaning to put something up like this myself. I feel like I gain so much information from just watching someone work, and having them open themselves up to questions.

Since I do not really use Ctrl-X on the terminal to cut text, I have changed my terminal configs to have Ctrl-X be sigint, and Ctrl-C to be copy. Makes for a nicer experience, also X looks more like a "kill" :)

Haven't looked at the link, but I think for a scenario like trading where there are market open and close times, you can just disable the GC, and restart the program after market close.

I'm not a mathematician (but I've seen exact sequences and commutative diagrams) and to me the stuff out of his IUT papers[0] looks borderline LLM-generated. I can only imagine what the LaTeX source looks like.

[0]: https://www.kurims.kyoto-u.ac.jp/~motizuki/Inter-universal%2...

Thanks! The main thing that I had difficulty with, which you can see from the typst source, is the rendering and spacing around inline math symbols. They are rendered as SVGs, which is fine but then copying them doesn't work. Their spacing is sometimes unpredictable so I'll add something like $thick x + y$ to pad on the left hand side. I'm not sure what parts of the math symbol contribute to the dimensions of the SVG and I'm sure it's rather complex, but other than that the experience has been solid.

It works really well, I've written three blog posts using typst.

Post: https://ezb.io/thoughts/interaction_nets/lambda_calculus/202...

Typst source: https://github.com/enricozb/enricozb.github.io/blob/master/t...

Lambda variables are also scoped, in the sense that a bound variable shadows one with the same name if it is in scope at bind-time. When looking at lambda calculus as purely a term rewriting system, the rule for substitution is just a bit nuanced, that's all. With DeBruijn notation, substitution is a much simpler operation.

Differentiable Logic Gate Networks [0] are super interesting. However, I still don't like that the wiring is fixed initially rather than learned.

I did some extremely rough research into doing learnable wirings [1], but couldn't get past even learning ~4-bit addition.

[0]: https://arxiv.org/abs/2210.08277

[1]: https://ezb.io/thoughts/program_synthesis/boolean_circuits/2...

Maybe Sciral Consistency?

nominative determinism

Yes, you're not the first to have asked this. I'll add one before I publish the next post.

Working on writing a series of blog posts on interaction nets. The first one is up already an is an introduction to the topic [0]. I feel like the topic is very accessible but the ideas are spread out across discord channels, papers, twitter, and GitHub repos. Hoping to centralize it a bit.

[0]: https://ezb.io/thoughts/interaction_nets/lambda_calculus/202...

Working on ARC-AGI (2). Trying a few different approaches including gradient descent mechanisms to construct programs in DSLs. Was really inspired by the recent differentiable logic gate networks work from Google, and believe there is a way to adapt it to generate programs instead of cellular automata rules.

Somewhat related: the Lambek calculus[0], which is kind of a general type system for written languages. Words are either functions or concrete types, and functions can take their arguments on the left or right.

I wish fd and rg would align some of their flags. For example, both fd and rg have a --type, but for fd it means file/directory/symlink etc. For rg it means the file MIME type. Another example is that fd has an --extension flag, and rg doesn't.

Since I believe the correlation of usage of these tools is high, I think they could benefit from having similarly named flags.

> Every Nintendo handheld up to the 3DS contains a GameBoy inside it!

I think this was quoted from elsewhere within the post but, is this true? If by "up to" we're not including the 3DS, the DSi and DSi XL still don't contain a GBA slot. I don't _think_ they contain the hardware either b/c with homebrew I believe the GBA games are emulated on those newer devices.

Am I mistaken here?

Hmm I'll have to look into this. After some basic playing around with this feature it might be workable. In my head I had my editor taking over the current program in the terminal, and after exiting it would return to the previous program, but that involves some backgrounding and job manipulation that I haven't given too much thought. Thanks for the tip.