arijun

That seems like a recipe for nefarious code insertion.

If you’re worried about bit-flipping, you could just store multiple copies of the hash and then do voting, since it’s small. If you’re worried about correlated sources of error that helps less, though.

(I can’t respond to your other comment)

Ah I see, you’re saying that the construction of a list in F# mandates a lambda, thereby reducing one possible point of confusion. I could agree with that. But then it comes at a cost of comfort: [0]*4 has less boilerplate than the F# version. So it comes down to trade-offs again.

Are you saying f# special-cases something that looks like a closure, but isn’t in this one context? Because that, to me, seems like a much more grievous issue than the one at hand.

Why are you comparing functions/closures with values? You can do the same in python:

  [list() for _ in range(4)]

Languages with immutable data structures are relatively rare. With its high level focus python could have been one of them, but went for different trade offs.

> In more sane languages, the expression [] means give me an empty list value, nothing more and nothing less

What is a “list value”? It’s either a pointer to some other space where the lists values are stored, or it’s the values stored themselves. If you say it’s the second (I can’t think of any language that does), then `a = […]; b = a` is an expensive copy by value assignment. Is that worth that trade off to get less surprising results in the articles case? I’m not saying the answer is “obviously no”, but it definitely isn’t “obviously yes”.

Languages with immutable data structures are relatively rare. With its high level focus python could have been one of them, but went for different trade offs.

> In more sane languages, the expression [] means give me an empty list value, nothing more and nothing less

What is an “empty list value”?

My point was that both are static, but you’re right that one being done at the type checking stage probably makes a big difference in the feasibility.

> the potential to produce surprising results

That’s actually the big reason for that capability. If you do

    let result: Result<_,!> = …
    let ok(fine) = result

, if result ever changes from infallible to fallible, you get a compile error rather than the runtime error you would get with unwrap. In fact, when looking it up, it turns out that specific case was a big part of the motivation for the “!” type in the first place! I think the above code probably compiles in nightly because of that.

If, as another poster claimed, the data never leaves your device, you absolutely can have privacy. Some people might prefer a stricter form, but it’s not nothing.

The case at the beginning, where we know our pattern is irrefutable but the compiler doesn't (let (x, 2) = (1, 1+1)) ,is something the compiler could easily prove (as long as the irrefutably could be proven locally as it is here). At first, I struggled to think of why that capability would ever be helpful. In the end, though, I came up with this example, which can (and does) come up:

  fn infallible() -> Result<u8, !>{
      Ok(1)
  }
  
  fn match_infallible(){
      let Ok(x) = infallible();
  }

The compiler here knows the `infallible` function will always return an `Ok` because of the return type. Here you could just `unwrap` the result, but what if it was inside a tuple, or something similar?

I don’t think it’s a given that people do. Also what does that have to do with the article?

What does “isn’t afraid of the letter S” mean?

What about suspending the ethanol like in alcohol gel? Could we find a gelling agent that is less irritating than the quat disinfectant residue?

I wonder if you could use the multilingual capabilities to workaround it's own censorship? I.e. what would happen if you asked it to translate the query to English, asked it in English, and then asked it to translate back to Chinese.

I always assume that any difficult/annoying anti-fingerprint techniques make you more identifiable instead of less, since very few people do them.

It’s funny because lisp enthusiasts will say “yes, lisp is harder to learn with all the parentheses, but trust me, it’s worth it” And then list some actual benefits.

Whereas APL fans will insist it’s not hard while listing no benefits besides dense code.

The lack of familiarity was exactly my point? If you make a new language with a + symbol but spelled out the other functions, newcomers would understand it immediately. If you have whatever that Christmas tree symbol is, newcomers will be continuously looking up what they mean. You are making the language harder to learn for the sake of code golf.

And if you had a toggle-able mode, you could still have your code golf.

An obvious compromise is to have a dual representation, one terse and one that’s spelled out. You could then toggle between them when seeing unfamiliar symbols.

The fact that nobody selling me on these arcane runes talks about something like that tells me it’s more about code golf for them.

The white paper answered me right in the abstract!

> …written in Rust, addressing a challenge in real-world use of logic programming languages: the fact that logical programs are parts of bigger software systems and need to interoperate with other components written in imperative programming languages.

Looks cool, although I wonder a bit at the benefit of writing it as a dsl in Rust. It seems like you would usually write the whole program in the dsl and just hit run in regular Rust.

Is it not possible that they decide to add something as configurable that is currently allowed everywhere? As an analogy, when Apple decided to make the ID of a user opt-in.

The gyroscopic effect of wheels has a minimal impact on the tendency of things like bicycles to remain balanced; the majority of the effect comes from the rake of the front wheel (i.e. that the point where it touches the ground is ahead of the pivot point of the front post).

That gyroscopic effect of the wheel works well when the whole device is wheel (think hoop rolling), but when you start adding weight that's not spinning (like someone riding a scooter), the effect falls off.

Edit: it seems that neither the gyroscopic effect nor rake are sufficient to explain bicycles' self-stability: https://en.wikipedia.org/wiki/Two-mass-skate_bicycle

[2008]

Videogamedunkey has an entertaining survey of the streaming landscape:

https://www.youtube.com/watch?v=yvhv7bgmz64

That’s a bit silly of a thought experiment, because nothing survives it, since everything has its niche. If we had started with smartphones, computers coming along with their big screens and external input devices, people would be flooding to them. Even the timeline we have doesn’t survive—when smartphones came out it turned out people love having computing accessible from their pocket.

Off the top of my head, I can think of two reasons why it might be preferable to have the government intervene.

1) We are happy to have the government intervene in other cases for the sake of children; I would be pretty upset at any politician who espoused removing age restrictions on cigarettes. I don’t know that social media is as bad but it certainly has some of the addictive properties

2) An argument from tragedy of the masses: if all kids’ social lives currently revolve around social media, unilaterally disallowing one child to use it could result in alienation from their peer group, which might be worse for the kid than social media. A government mandate would remove this issue.

Just watched the video—it has the same failings as most other debunking videos (e.g. Thunderf00t): in order to get views he must show that what he is debunking is very wrong, and so manufactures gotchas. It’s a little ironic that his video accusing Veratasium of lacking nuance is completely lacking nuance itself. Although admittedly, he’s not wrong that Veratasium is lacking nuance and is too breathless in his praise.

Everyone on here is complaining about the tips, but I don’t see a way to break tipping culture. Are we going to keep ratcheting up tip percentages forever or is there a solution?

For me it’s depended on where I am at the time. In LA it would do exactly that, having me cross many lanes in heavy traffic, but elsewhere it was fine.

My theory is that Waze must model what maneuvers are possible/easy based on other drivers in the area. So if you live in an area with more aggressive drivers it assumes those maneuvers are easier to do.

Are there no overwrite/seek bugs in Unix that could be exploited in that case? It seems to me like only using sudo for a cp command would reduce the attack surface.